Loading FIP layer data file

vdyp-core/src/main/java/ca/bc/gov/nrs/vdyp/io/EndOfRecord.java

@@ -0,0 +1,5 @@
+package ca.bc.gov.nrs.vdyp.io;
+
+public enum EndOfRecord {
+	END_OF_RECORD
+}

vdyp-core/src/main/java/ca/bc/gov/nrs/vdyp/io/parse/GroupingStreamingParser.java

@@ -0,0 +1,99 @@
+package ca.bc.gov.nrs.vdyp.io.parse;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Wraps a StreamingParser and groups its entries.
+ *
+ * @author Kevin Smith, Vivid Solutions
+ *
+ * @param <T>
+ * @param <U>
+ */
+public abstract class GroupingStreamingParser<T, U> implements StreamingParser<T> {
+
+	final StreamingParser<U> delegate;
+
+	Optional<List<U>> next = Optional.empty();
+
+	public GroupingStreamingParser(StreamingParser<U> delegate) {
+		super();
+		this.delegate = delegate;
+	}
+
+	/**
+	 * Returns true if a child should be skipped
+	 *
+	 * @param nextChild
+	 * @return
+	 */
+	protected abstract boolean skip(U nextChild);
+
+	/**
+	 * Returns true if a schild is an end of group marker
+	 *
+	 * @param nextChild
+	 * @return
+	 */
+	protected abstract boolean stop(U nextChild);
+
+	/**
+	 * Convert a list of children to a result.
+	 *
+	 * @param children
+	 * @return
+	 */
+	protected abstract T convert(List<U> children);
+
+	@Override
+	public T next() throws IOException, ResourceParseException {
+
+		doGetNext();
+		var children = next.orElseThrow(() -> new IllegalStateException("Requested next group when there is none"));
+		next = Optional.empty();
+		return convert(children);
+	}
+
+	protected void doGetNext() throws IOException, ResourceParseException {
+
+		if (next.isEmpty()) {
+			var nextResult = new ArrayList<U>();
+
+			var nextChild = safeNextChild();
+			while (nextChild.map(x -> !stop(x)).orElse(false)) {
+				nextResult.add(nextChild.get());
+				nextChild = safeNextChild();
+			}
+			if (nextChild.isEmpty()) {
+				return;
+			}
+			next = Optional.of(nextResult);
+
+		}
+	}
+
+	protected Optional<U> safeNextChild() throws IOException, ResourceParseException {
+		Optional<U> result = Optional.empty();
+		while (result.isEmpty() && delegate.hasNext()) {
+			if (delegate.hasNext())
+				result = Optional.of(delegate.next()).filter(x -> !skip(x));
+		}
+		return result;
+	}
+
+	@Override
+	public boolean hasNext() throws IOException, ResourceParseException {
+		doGetNext();
+
+		return next.isPresent();
+	}
+
+	@Override
+	public void close() throws IOException {
+		delegate.close();
+	}
+
+}

vdyp-core/src/main/java/ca/bc/gov/nrs/vdyp/io/parse/ValueParser.java

@@ -7,7 +7,10 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
+import ca.bc.gov.nrs.vdyp.common.ValueOrMarker;
+import ca.bc.gov.nrs.vdyp.model.Layer;
 import ca.bc.gov.nrs.vdyp.model.Region;
 
 /**
@@ -205,4 +208,57 @@ public static <U> ValueParser<List<U>> segmentList(int length, ValueParser<U> de
 	static <U> ValueParser<U> uncontrolled(ControlledValueParser<U> delegate) {
 		return s -> delegate.parse(s, Collections.emptyMap());
 	}
+
+	/**
+	 * Attempt to parse as a marker using markerParser. If it returns empty, parse
+	 * as a value with valueParser.
+	 *
+	 * @param valueParser  Parser from String to Value.
+	 * @param markerParser Parser from String to Optional<Marker>. This should
+	 *                     return empty if the string is not a marker.
+	 * @return a ValueOrMarker
+	 */
+	public static <Value, Marker> ValueParser<ValueOrMarker<Value, Marker>>
+			valueOrMarker(ValueParser<Value> valueParser, ValueParser<Optional<Marker>> markerParser) {
+		return s -> {
+			var builder = new ValueOrMarker.Builder<Value, Marker>();
+			var marker = markerParser.parse(s).map(builder::marker);
+			if (marker.isPresent()) {
+				return marker.get();
+			}
+
+			var value = builder.value(valueParser.parse(s));
+			return value;
+		};
+	}
+
+	/**
+	 * Return the given value if the test passes, otherwise empty.
+	 *
+	 * @param <T>
+	 * @param test
+	 * @param value
+	 * @return
+	 */
+	public static <T> ValueParser<Optional<T>> optionalSingleton(Predicate<String> test, T value) {
+		return s -> test.test(s) ? Optional.of(value) : Optional.empty();
+	}
+
+	/**
+	 * Parser for a layer identifier
+	 */
+	public static ValueParser<Optional<Layer>> LAYER = s -> {
+		switch (s.toUpperCase()) {
+		case "1":
+		case "P":
+			return Optional.of(Layer.PRIMARY);
+		case "2":
+		case "S":
+			return Optional.of(Layer.SECONDARY);
+		case "V":
+			return Optional.of(Layer.VETERAN);
+		default:
+			return Optional.empty(); // Unknown
+		}
+	};
 }

vdyp-core/src/main/java/ca/bc/gov/nrs/vdyp/model/Layer.java

@@ -0,0 +1,5 @@
+package ca.bc.gov.nrs.vdyp.model;
+
+public enum Layer {
+	PRIMARY, SECONDARY, VETERAN
+}

vdyp-core/src/test/java/ca/bc/gov/nrs/vdyp/io/parse/GroupingStreamingParserTest.java

@@ -0,0 +1,215 @@
+package ca.bc.gov.nrs.vdyp.io.parse;
+
+import static ca.bc.gov.nrs.vdyp.test.VdypMatchers.assertEmpty;
+import static ca.bc.gov.nrs.vdyp.test.VdypMatchers.assertNext;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.easymock.EasyMock;
+import org.junit.jupiter.api.Test;
+
+public class GroupingStreamingParserTest {
+
+	@Test
+	public void testEmpty() throws Exception {
+		var control = EasyMock.createControl();
+
+		StreamingParser<Integer> delegate = control.createMock("delegate", StreamingParser.class);
+
+		EasyMock.expect(delegate.hasNext()).andStubReturn(false);
+
+		control.replay();
+
+		var unit = new GroupingStreamingParser<List<Integer>, Integer>(delegate) {
+
+			@Override
+			protected boolean skip(Integer nextChild) {
+				return nextChild % 3 == 0;
+			}
+
+			@Override
+			protected boolean stop(Integer nextChild) {
+				return nextChild % 5 == 0;
+			}
+
+			@Override
+			protected List<Integer> convert(List<Integer> children) {
+				return children;
+			}
+
+		};
+
+		assertEmpty(unit);
+
+		control.verify();
+	}
+
+	@Test
+	public void testOneEntry() throws Exception {
+		var control = EasyMock.createControl();
+
+		var mock = Arrays.asList(1, 5).iterator();
+
+		StreamingParser<Integer> delegate = control.createMock("delegate", StreamingParser.class);
+
+		EasyMock.expect(delegate.hasNext()).andStubAnswer(mock::hasNext);
+		EasyMock.expect(delegate.next()).andStubAnswer(mock::next);
+
+		control.replay();
+
+		var unit = new GroupingStreamingParser<List<Integer>, Integer>(delegate) {
+
+			@Override
+			protected boolean skip(Integer nextChild) {
+				return nextChild % 3 == 0;
+			}
+
+			@Override
+			protected boolean stop(Integer nextChild) {
+				return nextChild % 5 == 0;
+			}
+
+			@Override
+			protected List<Integer> convert(List<Integer> children) {
+				return children;
+			}
+
+		};
+
+		var group = assertNext(unit);
+		assertThat(group, contains(1));
+
+		assertEmpty(unit);
+
+		control.verify();
+	}
+
+	@Test
+	public void testMultipleEntries() throws Exception {
+		var control = EasyMock.createControl();
+
+		var mock = Arrays.asList(1, 2, 5).iterator();
+
+		StreamingParser<Integer> delegate = control.createMock("delegate", StreamingParser.class);
+
+		EasyMock.expect(delegate.hasNext()).andStubAnswer(mock::hasNext);
+		EasyMock.expect(delegate.next()).andStubAnswer(mock::next);
+
+		control.replay();
+
+		var unit = new GroupingStreamingParser<List<Integer>, Integer>(delegate) {
+
+			@Override
+			protected boolean skip(Integer nextChild) {
+				return nextChild % 3 == 0;
+			}
+
+			@Override
+			protected boolean stop(Integer nextChild) {
+				return nextChild % 5 == 0;
+			}
+
+			@Override
+			protected List<Integer> convert(List<Integer> children) {
+				return children;
+			}
+
+		};
+
+		var group = assertNext(unit);
+		assertThat(group, contains(1, 2));
+
+		assertEmpty(unit);
+
+		control.verify();
+
+	}
+
+	@Test
+	public void testMultipleGroups() throws Exception {
+		var control = EasyMock.createControl();
+
+		var mock = Arrays.asList(1, 5, 2, 5).iterator();
+
+		StreamingParser<Integer> delegate = control.createMock("delegate", StreamingParser.class);
+
+		EasyMock.expect(delegate.hasNext()).andStubAnswer(mock::hasNext);
+		EasyMock.expect(delegate.next()).andStubAnswer(mock::next);
+
+		control.replay();
+
+		var unit = new GroupingStreamingParser<List<Integer>, Integer>(delegate) {
+
+			@Override
+			protected boolean skip(Integer nextChild) {
+				return nextChild % 3 == 0;
+			}
+
+			@Override
+			protected boolean stop(Integer nextChild) {
+				return nextChild % 5 == 0;
+			}
+
+			@Override
+			protected List<Integer> convert(List<Integer> children) {
+				return children;
+			}
+
+		};
+
+		var group = assertNext(unit);
+		assertThat(group, contains(1));
+
+		group = assertNext(unit);
+		assertThat(group, contains(2));
+
+		assertEmpty(unit);
+
+		control.verify();
+
+	}
+
+	@Test
+	public void testSkip() throws Exception {
+		var control = EasyMock.createControl();
+
+		var mock = Arrays.asList(3, 1, 5).iterator();
+
+		StreamingParser<Integer> delegate = control.createMock("delegate", StreamingParser.class);
+
+		EasyMock.expect(delegate.hasNext()).andStubAnswer(mock::hasNext);
+		EasyMock.expect(delegate.next()).andStubAnswer(mock::next);
+
+		control.replay();
+
+		var unit = new GroupingStreamingParser<List<Integer>, Integer>(delegate) {
+
+			@Override
+			protected boolean skip(Integer nextChild) {
+				return nextChild % 3 == 0;
+			}
+
+			@Override
+			protected boolean stop(Integer nextChild) {
+				return nextChild % 5 == 0;
+			}
+
+			@Override
+			protected List<Integer> convert(List<Integer> children) {
+				return children;
+			}
+
+		};
+
+		var group = assertNext(unit);
+		assertThat(group, contains(1));
+
+		assertEmpty(unit);
+
+		control.verify();
+	}
+
+}