#280: Changed Value into an interface, extracted functionality into C…

…oreValue.
parsingdata · Feb 7, 2019 · f3db1f8 · f3db1f8
1 parent c62b097
commit f3db1f8
Show file tree

Hide file tree

Showing 50 changed files with 182 additions and 140 deletions.
diff --git a/core/src/main/java/io/parsingdata/metal/Shorthand.java b/core/src/main/java/io/parsingdata/metal/Shorthand.java
@@ -45,6 +45,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.CoreValue;
 import io.parsingdata.metal.expression.value.Elvis;
 import io.parsingdata.metal.expression.value.Expand;
 import io.parsingdata.metal.expression.value.FoldCat;
@@ -176,7 +177,7 @@ private Shorthand() {}
     public static ValueExpression con(final String value) { return con(value, DEFAULT_ENCODING); }
     public static ValueExpression con(final String value, final Encoding encoding) { return con(ConstantFactory.createFromString(value, encoding)); }
     public static ValueExpression con(final Value value) { return new Const(value); }
-    public static ValueExpression con(final Encoding encoding, final int... values) { return new Const(new Value(createFromBytes(toByteArray(values)), encoding)); }
+    public static ValueExpression con(final Encoding encoding, final int... values) { return new Const(new CoreValue(createFromBytes(toByteArray(values)), encoding)); }
     public static ValueExpression con(final int... values) { return con(DEFAULT_ENCODING, values); }
     public static ValueExpression con(final byte[] value) { return con(value, DEFAULT_ENCODING); }
     public static ValueExpression con(final byte[] value, final Encoding encoding) { return con(ConstantFactory.createFromBytes(value, encoding)); }

diff --git a/core/src/main/java/io/parsingdata/metal/Util.java b/core/src/main/java/io/parsingdata/metal/Util.java
@@ -28,6 +28,7 @@
 import io.parsingdata.metal.data.ParseState;
 import io.parsingdata.metal.data.Slice;
 import io.parsingdata.metal.encoding.Encoding;
+import io.parsingdata.metal.expression.value.CoreValue;
 import io.parsingdata.metal.expression.value.UnaryValueExpression;
 import io.parsingdata.metal.expression.value.Value;
 import io.parsingdata.metal.expression.value.ValueExpression;
@@ -105,7 +106,7 @@ public Optional<Value> eval(final Value value, final ParseState parseState, fina
                         return Optional.empty();
                     }
                 }
-                return Optional.of(new Value(Slice.createFromBytes(out.toByteArray()), encoding));
+                return Optional.of(new CoreValue(Slice.createFromBytes(out.toByteArray()), encoding));
             }
         };
     }

diff --git a/core/src/main/java/io/parsingdata/metal/data/ConcatenatedValueSource.java b/core/src/main/java/io/parsingdata/metal/data/ConcatenatedValueSource.java
@@ -24,7 +24,7 @@
 import static io.parsingdata.metal.Util.checkNotNull;
 import static io.parsingdata.metal.Util.format;
 import static io.parsingdata.metal.data.Selection.reverse;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.math.BigInteger;
 import java.util.Objects;
@@ -64,7 +64,7 @@ private static Trampoline<BigInteger> calculateTotalSize(final ImmutableList<Val
         if (values.head == NOT_A_VALUE) {
             return complete(() -> ZERO);
         }
-        return intermediate(() -> calculateTotalSize(values.tail, size.add(values.head.slice.length)));
+        return intermediate(() -> calculateTotalSize(values.tail, size.add(values.head.getSlice().length)));
     }
 
     @Override
@@ -79,13 +79,13 @@ private Trampoline<byte[]> getData(final ImmutableList<Value> values, final BigI
         if (length.compareTo(ZERO) <= 0) {
             return complete(() -> output);
         }
-        if (currentOffset.add(values.head.slice.length).compareTo(offset) <= 0) {
-            return intermediate(() -> getData(values.tail, currentOffset.add(values.head.slice.length), currentDest, offset, length, output));
+        if (currentOffset.add(values.head.getSlice().length).compareTo(offset) <= 0) {
+            return intermediate(() -> getData(values.tail, currentOffset.add(values.head.getSlice().length), currentDest, offset, length, output));
         }
         final BigInteger localOffset = offset.subtract(currentOffset).compareTo(ZERO) < 0 ? ZERO : offset.subtract(currentOffset);
-        final BigInteger toCopy = length.compareTo(values.head.slice.length.subtract(localOffset)) > 0 ? values.head.slice.length.subtract(localOffset) : length;
-        System.arraycopy(values.head.slice.getData(), localOffset.intValueExact(), output, currentDest.intValueExact(), toCopy.intValueExact());
-        return intermediate(() -> getData(values.tail, currentOffset.add(values.head.slice.length), currentDest.add(toCopy), offset, length.subtract(toCopy), output));
+        final BigInteger toCopy = length.compareTo(values.head.getSlice().length.subtract(localOffset)) > 0 ? values.head.getSlice().length.subtract(localOffset) : length;
+        System.arraycopy(values.head.getSlice().getData(), localOffset.intValueExact(), output, currentDest.intValueExact(), toCopy.intValueExact());
+        return intermediate(() -> getData(values.tail, currentOffset.add(values.head.getSlice().length), currentDest.add(toCopy), offset, length.subtract(toCopy), output));
     }
 
     @Override

diff --git a/core/src/main/java/io/parsingdata/metal/data/DataExpressionSource.java b/core/src/main/java/io/parsingdata/metal/data/DataExpressionSource.java
@@ -21,6 +21,7 @@
 import static io.parsingdata.metal.Util.checkNotNegative;
 import static io.parsingdata.metal.Util.checkNotNull;
 import static io.parsingdata.metal.Util.format;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.math.BigInteger;
 import java.util.Objects;
@@ -71,7 +72,7 @@ private synchronized byte[] getValue() {
                 throw new IllegalStateException(format("ValueExpression dataExpression must yield at least %d results.", index+1));
             }
             final Value cacheValue = getValueAtIndex(results, index, 0).computeResult();
-            if (cacheValue == Value.NOT_A_VALUE) {
+            if (cacheValue == NOT_A_VALUE) {
                 throw new IllegalStateException(format("ValueExpression dataExpression yields empty Value at index %d.", index));
             }
             cache = cacheValue.getValue();

diff --git a/core/src/main/java/io/parsingdata/metal/data/ParseValue.java b/core/src/main/java/io/parsingdata/metal/data/ParseValue.java
@@ -22,10 +22,10 @@
 import java.util.Objects;
 
 import io.parsingdata.metal.encoding.Encoding;
-import io.parsingdata.metal.expression.value.Value;
+import io.parsingdata.metal.expression.value.CoreValue;
 import io.parsingdata.metal.token.Token;
 
-public class ParseValue extends Value implements ParseItem {
+public class ParseValue extends CoreValue implements ParseItem {
 
     public final String name;
     public final Token definition;

diff --git a/core/src/main/java/io/parsingdata/metal/data/Selection.java b/core/src/main/java/io/parsingdata/metal/data/Selection.java
@@ -57,7 +57,7 @@ public static Trampoline<Optional<ParseItem>> findItemAtOffset(final ImmutableLi
     }
 
     private static boolean matchesLocation(final ParseValue value, final BigInteger offset, final Source source) {
-        return value.slice.offset.compareTo(offset) == 0 && value.slice.source.equals(source);
+        return value.getSlice().offset.compareTo(offset) == 0 && value.getSlice().source.equals(source);
     }
 
     private static Trampoline<ParseValue> getLowestOffsetValue(final ImmutableList<ParseGraph> graphList, final ParseValue lowest) {
@@ -77,7 +77,7 @@ private static ParseValue compareIfValue(final ParseValue lowest, final ParseIte
     }
 
     private static ParseValue getLowest(final ParseValue lowest, final ParseValue value) {
-        return lowest == null || lowest.slice.offset.compareTo(value.slice.offset) > 0 ? value : lowest;
+        return lowest == null || lowest.getSlice().offset.compareTo(value.getSlice().offset) > 0 ? value : lowest;
     }
 
     private static ImmutableList<ParseGraph> addIfGraph(final ImmutableList<ParseGraph> graphList, final ParseItem head) {

diff --git a/core/src/main/java/io/parsingdata/metal/expression/comparison/ComparisonExpression.java b/core/src/main/java/io/parsingdata/metal/expression/comparison/ComparisonExpression.java
@@ -19,7 +19,7 @@
 import static io.parsingdata.metal.Trampoline.complete;
 import static io.parsingdata.metal.Trampoline.intermediate;
 import static io.parsingdata.metal.Util.checkNotNull;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.util.Objects;
 

diff --git a/core/src/main/java/io/parsingdata/metal/expression/comparison/Eq.java b/core/src/main/java/io/parsingdata/metal/expression/comparison/Eq.java
@@ -40,7 +40,7 @@ public Eq(final ValueExpression value, final ValueExpression predicate) {
 
     @Override
     public boolean compare(final Value left, final Value right) {
-        return left.slice.length.compareTo(right.slice.length) == 0
+        return left.getSlice().length.compareTo(right.getSlice().length) == 0
             && Arrays.equals(left.getValue(), right.getValue());
     }
 

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/BinaryValueExpression.java b/core/src/main/java/io/parsingdata/metal/expression/value/BinaryValueExpression.java
@@ -20,7 +20,7 @@
 import static io.parsingdata.metal.Trampoline.intermediate;
 import static io.parsingdata.metal.Util.checkNotNull;
 import static io.parsingdata.metal.data.Selection.reverse;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.util.Objects;
 import java.util.Optional;

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/Bytes.java b/core/src/main/java/io/parsingdata/metal/expression/value/Bytes.java
@@ -22,7 +22,7 @@
 import static io.parsingdata.metal.Trampoline.intermediate;
 import static io.parsingdata.metal.Util.checkNotNull;
 import static io.parsingdata.metal.data.Slice.createFromSource;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.math.BigInteger;
 import java.util.Objects;
@@ -74,7 +74,7 @@ private Trampoline<ImmutableList<Value>> extractByteValues(final ImmutableList<V
         if (value == NOT_A_VALUE || BigInteger.valueOf(i).compareTo(value.getLength()) >= 0) {
             return complete(() -> output);
         }
-        return intermediate(() -> extractByteValues(output.add(new Value(createFromSource(value.slice.source, value.slice.offset.add(BigInteger.valueOf(i)), ONE).get(), encoding)), value, i + 1, encoding));
+        return intermediate(() -> extractByteValues(output.add(new CoreValue(createFromSource(value.getSlice().source, value.getSlice().offset.add(BigInteger.valueOf(i)), ONE).get(), encoding)), value, i + 1, encoding));
     }
 
     @Override

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/Cat.java b/core/src/main/java/io/parsingdata/metal/expression/value/Cat.java
@@ -40,7 +40,7 @@ public Cat(final ValueExpression left, final ValueExpression right) {
     public Optional<Value> eval(final Value leftValue, final Value rightValue, final ParseState parseState, final Encoding encoding) {
         return ConcatenatedValueSource.create(ImmutableList.create(leftValue).add(rightValue))
             .flatMap(source -> createFromSource(source, ZERO, leftValue.getLength().add(rightValue.getLength())))
-            .map(source -> new Value(source, encoding));
+            .map(source -> new CoreValue(source, encoding));
     }
 
 }
diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/ConstantFactory.java b/core/src/main/java/io/parsingdata/metal/expression/value/ConstantFactory.java
@@ -29,7 +29,7 @@ public final class ConstantFactory {
     private ConstantFactory() {}
 
     public static Value createFromBytes(final byte[] value, final Encoding encoding) {
-        return new Value(Slice.createFromBytes(value), encoding);
+        return new CoreValue(Slice.createFromBytes(value), encoding);
     }
 
     public static Value createFromNumeric(final BigInteger value, final Encoding encoding) {
@@ -41,14 +41,14 @@ public static Value createFromNumeric(final long value, final Encoding encoding)
     }
 
     public static Value createFromString(final String value, final Encoding encoding) {
-        return new Value(Slice.createFromBytes(value.getBytes(encoding.charset)), encoding);
+        return new CoreValue(Slice.createFromBytes(value.getBytes(encoding.charset)), encoding);
     }
 
     public static Value createFromBitSet(final BitSet value, final int minSize, final Encoding encoding) {
         final byte[] bytes = ByteOrder.LITTLE_ENDIAN.apply(value.toByteArray());
         final byte[] outBytes = new byte[Math.max(minSize, bytes.length)];
         System.arraycopy(bytes, 0, outBytes, outBytes.length - bytes.length, bytes.length);
-        return new Value(Slice.createFromBytes(outBytes), setToBigEndian(encoding));
+        return new CoreValue(Slice.createFromBytes(outBytes), setToBigEndian(encoding));
     }
 
     private static Encoding setToBigEndian(final Encoding encoding) {

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/CoreValue.java b/core/src/main/java/io/parsingdata/metal/expression/value/CoreValue.java
@@ -0,0 +1,99 @@
+/*
+ * 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;
+
+import static io.parsingdata.metal.Util.bytesToHexString;
+import static io.parsingdata.metal.Util.checkNotNull;
+import static io.parsingdata.metal.encoding.Encoding.DEFAULT_ENCODING;
+
+import java.math.BigInteger;
+import java.util.BitSet;
+import java.util.Objects;
+
+import io.parsingdata.metal.Util;
+import io.parsingdata.metal.data.Slice;
+import io.parsingdata.metal.encoding.ByteOrder;
+import io.parsingdata.metal.encoding.Encoding;
+import io.parsingdata.metal.encoding.Sign;
+
+public class CoreValue implements Value {
+
+    public static final Value NOT_A_VALUE = new CoreValue(Slice.createFromBytes(new byte[]{}), DEFAULT_ENCODING);
+    public static final BigInteger TO_STRING_BYTE_COUNT = BigInteger.valueOf(4);
+
+    private final Slice slice;
+    private final Encoding encoding;
+
+    public CoreValue(final Slice slice, final Encoding encoding) {
+        this.slice = checkNotNull(slice, "slice");
+        this.encoding = checkNotNull(encoding, "encoding");
+    }
+
+    @Override
+    public Slice getSlice() {
+        return slice;
+    }
+
+    @Override
+    public Encoding getEncoding() {
+        return encoding;
+    }
+
+    @Override
+    public byte[] getValue() {
+        return slice.getData();
+    }
+
+    @Override
+    public BigInteger getLength() {
+        return slice.length;
+    }
+
+    @Override
+    public BigInteger asNumeric() {
+        return encoding.sign == Sign.SIGNED ? new BigInteger(encoding.byteOrder.apply(getValue()))
+                                            : new BigInteger(1, encoding.byteOrder.apply(getValue()));
+    }
+
+    @Override
+    public String asString() {
+        return new String(getValue(), encoding.charset);
+    }
+
+    @Override
+    public BitSet asBitSet() {
+        return BitSet.valueOf(encoding.byteOrder == ByteOrder.BIG_ENDIAN ? ByteOrder.LITTLE_ENDIAN.apply(getValue()) : getValue());
+    }
+
+    @Override
+    public String toString() {
+        return "0x" + bytesToHexString(slice.getData(TO_STRING_BYTE_COUNT)) + (getLength().compareTo(TO_STRING_BYTE_COUNT) > 0 ? "..." : "");
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        return Util.notNullAndSameClass(this, obj)
+            && Objects.equals(slice, ((CoreValue)obj).slice)
+            && Objects.equals(encoding, ((CoreValue)obj).encoding);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getClass(), slice, encoding);
+    }
+
+}
diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/Elvis.java b/core/src/main/java/io/parsingdata/metal/expression/value/Elvis.java
@@ -20,7 +20,7 @@
 import static io.parsingdata.metal.Trampoline.intermediate;
 import static io.parsingdata.metal.Util.checkNotNull;
 import static io.parsingdata.metal.data.Selection.reverse;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.util.Objects;
 import java.util.Optional;

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/Expand.java b/core/src/main/java/io/parsingdata/metal/expression/value/Expand.java
@@ -19,7 +19,7 @@
 import static io.parsingdata.metal.Trampoline.complete;
 import static io.parsingdata.metal.Trampoline.intermediate;
 import static io.parsingdata.metal.Util.checkNotNull;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.util.Objects;
 

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/Fold.java b/core/src/main/java/io/parsingdata/metal/expression/value/Fold.java
@@ -19,7 +19,7 @@
 import static io.parsingdata.metal.Trampoline.complete;
 import static io.parsingdata.metal.Trampoline.intermediate;
 import static io.parsingdata.metal.Util.checkNotNull;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.util.Objects;
 import java.util.function.BinaryOperator;

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/FoldCat.java b/core/src/main/java/io/parsingdata/metal/expression/value/FoldCat.java
@@ -47,7 +47,7 @@ public FoldCat(final ValueExpression operand) {
     public ImmutableList<Value> eval(final ParseState parseState, final Encoding encoding) {
         return ConcatenatedValueSource.create(operand.eval(parseState, encoding))
             .flatMap(source -> createFromSource(source, ZERO, source.length))
-            .map(slice -> ImmutableList.create(new Value(slice, encoding)))
+            .map(slice -> ImmutableList.<Value>create(new CoreValue(slice, encoding)))
             .orElseGet(ImmutableList::new);
     }
 

diff --git a/core/src/main/java/io/parsingdata/metal/expression/value/UnaryValueExpression.java b/core/src/main/java/io/parsingdata/metal/expression/value/UnaryValueExpression.java
@@ -20,7 +20,7 @@
 import static io.parsingdata.metal.Trampoline.intermediate;
 import static io.parsingdata.metal.Util.checkNotNull;
 import static io.parsingdata.metal.data.Selection.reverse;
-import static io.parsingdata.metal.expression.value.Value.NOT_A_VALUE;
+import static io.parsingdata.metal.expression.value.CoreValue.NOT_A_VALUE;
 
 import java.util.Objects;
 import java.util.Optional;