Merge pull request #139 from bunkenburg/issues/JPX-72-parse-location

#72: Parse location

Author: jenetics

jpx/src/main/java/io/jenetics/jpx/format/CompositeFormat.java

@@ -19,6 +19,7 @@
  */
 package io.jenetics.jpx.format;
 
+import java.text.ParsePosition;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -29,16 +30,15 @@
  * @version 1.4
  * @since 1.4
  */
-final class CompositeFormat<T> implements Format<T> {
+class CompositeFormat implements Format {
 
-	private final List<Format<T>> _formats;
+	private final List<Format> _formats;
 
-	private CompositeFormat(final List<Format<T>> formats) {
+	private CompositeFormat(List<Format> formats) {
 		_formats = List.copyOf(formats);
 	}
 
-	@Override
-	public Optional<String> format(final T value) {
+	@Override public Optional<String> format(Location value) {
 		final List<Optional<String>> strings = _formats.stream()
 			.map(format -> format.format(value))
 			.collect(Collectors.toList());
@@ -52,15 +52,18 @@ public Optional<String> format(final T value) {
 			: Optional.empty();
 	}
 
-	@Override
-	public String toString() {
+	@Override public void parse(CharSequence in, ParsePosition pos, LocationBuilder b) throws ParseException {
+		for( Format f : _formats ) f.parse(in, pos, b);
+	}
+
+	@Override public String toPattern() {
 		return _formats.stream()
-			.map(Objects::toString)
+			.map( f -> f.toPattern() )
 			.collect(Collectors.joining());
 	}
 
-	static <T> CompositeFormat<T> of(final List<Format<T>> formats) {
-		return new CompositeFormat<>(formats);
+	static CompositeFormat of(List<Format> formats) {
+		return new CompositeFormat(formats);
 	}
 
 }

jpx/src/main/java/io/jenetics/jpx/format/ConstFormat.java

@@ -22,6 +22,7 @@
 import static java.util.Objects.requireNonNull;
 import static io.jenetics.jpx.format.LocationFormatter.PROTECTED_CHARS;
 
+import java.text.ParsePosition;
 import java.util.Optional;
 
 /**
@@ -31,7 +32,7 @@
  * @version 1.4
  * @since 1.4
  */
-final class ConstFormat<T> implements Format<T> {
+final class ConstFormat implements Format {
 
 	private final String _value;
 
@@ -45,16 +46,28 @@ private ConstFormat(final String value) {
 		_value = requireNonNull(value);
 	}
 
-	@Override
-	public Optional<String> format(final T value) {
+	@Override public Optional<String> format(Location value) {
 		return Optional.of(_value);
 	}
 
-	@Override
-	public String toString() {
-		return escape(_value);
+	/** parse _value */
+	@Override public void parse(CharSequence in, ParsePosition pos, LocationBuilder b) throws ParseException {
+		int start = pos.getIndex();
+		int end = start + _value.length();
+		if( end <= in.length()){
+			String s = in.subSequence(start, end).toString();
+			if(s.equals(_value)){
+				pos.setIndex(end);
+				// but no call to builder
+				return;
+			}
+		}
+		pos.setErrorIndex(start);
+		throw new ParseException("Not found constant \"" + _value + "\"", in, start);
 	}
 
+	@Override public String toPattern() { return escape(_value); }
+
 	private static String escape(final String value) {
 		final StringBuilder out = new StringBuilder();
 		boolean quote = false;
@@ -74,8 +87,8 @@ private static String escape(final String value) {
 			: out.toString();
 	}
 
-	static <T> ConstFormat<T> of(final String value) {
-		return new ConstFormat<>(value);
+	static ConstFormat of(final String value) {
+		return new ConstFormat(value);
 	}
 
 }

jpx/src/main/java/io/jenetics/jpx/format/Elevation.java

@@ -0,0 +1,42 @@
+package io.jenetics.jpx.format;
+
+import java.text.DecimalFormat;
+import java.text.ParsePosition;
+import java.util.Optional;
+
+import static io.jenetics.jpx.Length.Unit.METER;
+
+/**
+ * This field allows to access the elevation (in meter) of a given
+ * location.
+ */
+class Elevation extends Field {
+
+	private boolean prefixSign = false;
+
+	Elevation(String pattern){super(pattern);}
+
+	void setPrefixSign(boolean b){
+		prefixSign = b;
+		String decimalPattern = toDecimalPattern(pattern);
+		String p = b ? ("+" + decimalPattern + ";" + "-" + decimalPattern) :  decimalPattern;
+		nf = new DecimalFormat(p, symbols);
+	}
+
+	char type() { return 'E'; }
+
+	/** parse elevation as double */
+	@Override public void parse(CharSequence in, ParsePosition pos, LocationBuilder b) throws ParseException {
+		double d = parseDouble(in,pos);
+		b.setElevation(d);
+	}
+
+	@Override public Optional<String> format( Location loc) {
+		return loc.elevation()
+			.map( l -> l.to(METER) )
+			.map( d -> nf.format(d) );
+	}
+
+	@Override public String toPattern(){ return prefixSign ? "+" + pattern : pattern; }
+
+}

jpx/src/main/java/io/jenetics/jpx/format/ElevationSignFormat.java

@@ -0,0 +1,98 @@
+package io.jenetics.jpx.format;
+
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+import java.util.Locale;
+import java.util.Optional;
+
+import static java.lang.Math.*;
+
+/**
+ * Represents one of the existing location fields: latitude, longitude and
+ * elevation.
+ *
+ * @author <a href="mailto:franz.wilhelmstoetter@gmail.com">Franz Wilhelmstötter</a>
+ * @version 1.4
+ * @since 1.4
+ */
+abstract class Field implements Format {
+
+	protected final static DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(Locale.US);
+
+	protected NumberFormat nf;
+	protected final String pattern;
+
+	protected Field(String pattern){
+		String decimalPattern = toDecimalPattern(pattern);
+		this.nf = new DecimalFormat(decimalPattern, symbols);
+		this.pattern = pattern;
+	}
+
+	void setPrefixSign(boolean b){}
+
+	abstract char type();
+
+	protected double toMinutes(double degrees) {
+		double dd = abs(degrees);
+		return (dd - floor(dd)) * 60.0;
+	}
+
+	protected double toSeconds(double degrees) {
+		double dd = abs(degrees);
+		double d = floor(dd);
+		double m = floor((dd - d) * 60.0);
+		return (dd - d - m / 60.0) * 3600.0;
+	}
+
+	static Optional<Field> ofPattern(String pattern) {
+		// TODO better?
+		for (int i = 0; i < pattern.length(); ++i) {
+			char c = pattern.charAt(i);
+			switch (c){
+				case 'L': {
+					String p = pattern.replace('L', 'D');
+					return Optional.of(new LatitudeDegree(p));
+				}
+				case 'D': return Optional.of(new LatitudeDegree(pattern));
+				case 'M': return Optional.of(new LatitudeMinute(pattern));
+				case 'S': return Optional.of(new LatitudeSecond(pattern));
+				case 'l': {
+					String p = pattern.replace('l','d');
+					return Optional.of(new LongitudeDegree(p));
+				}
+				case 'd': return Optional.of(new LongitudeDegree(pattern));
+				case 'm': return Optional.of(new LongitudeMinute(pattern));
+				case 's': return Optional.of(new LongitudeSecond(pattern));
+				case 'E': return Optional.of(new Elevation(pattern));
+				case 'H': {
+					String p = pattern.replace('H', 'E');
+					return Optional.of(new Elevation(p));
+				}
+			}
+		}
+		return Optional.empty();
+	}
+
+	protected String toDecimalPattern(String pattern) { return pattern.replace(type(), '0'); }
+
+	@Override public String toPattern() { return pattern; }
+
+	protected double parseDouble(CharSequence in, ParsePosition pos){
+		int i = pos.getIndex();
+		String s = in.toString();
+		boolean strictWidth = 1 < nf.getMinimumIntegerDigits(); //better?
+		if(strictWidth) {
+			int end = i + toPattern().length(); // toPattern() rather than pattern because LatitudeDegree.toPattern()
+			s = in.subSequence(0, end).toString(); // don't eat more digits
+		}
+		Number n = nf.parse(s, pos);//Does not throw an exception; if no object can be parsed, index is unchanged.
+		if(i==pos.getIndex()) {
+			pos.setErrorIndex(i);
+			throw new ParseException("Not found " + pattern, in, i);
+		}
+		double d = n.doubleValue();
+		return d;
+	}
+}

jpx/src/main/java/io/jenetics/jpx/format/Field.java

@@ -19,27 +19,25 @@
  */
 package io.jenetics.jpx.format;
 
+import java.text.ParsePosition;
 import java.util.Optional;
 
-/**
- * Base interface for formatting (converting) a given type to it's string
- * representation.
+/** Base interface for formatting and parsing a location.
  *
  * @author <a href="mailto:franz.wilhelmstoetter@gmail.com">Franz Wilhelmstötter</a>
  * @version 1.4
- * @since 1.4
- */
-interface Format<T> {
+ * @since 1.4 */
+interface Format {
 
-	/**
-	 * Formats the given {@code value} to it's string representation. If it is
+	/** Formats the given {@code value} to its string representation. If it is
 	 * not possible to convert the {@code value} to a string,
 	 * {@link Optional#empty()} is returned.
-	 *
 	 * @param value the value which is converted to a string.
 	 * @return the converted value, or {@link Optional#empty()} if the format
-	 *         fails
-	 */
-	Optional<String> format(final T value);
+	 *         fails */
+	Optional<String> format(Location value);
+
+	void parse(CharSequence in, ParsePosition pos, LocationBuilder b) throws ParseException;
 
+	String toPattern();
 }