Lots of changes for 0.10 release

Author: CodesAway

BEXCodeCompare/src/main/java/info/codesaway/bex/BEXPair.java

@@ -18,10 +18,12 @@
  * Pair of left and right values, which are of the same type
  *
  * <p>Instances of this class are immutable if generic class type is also immutable</p>
+ *
+ * <p>Instances of this class are Comparable if generic class type is also Comparable</p>
  * @param <T> the type of pair
  * @since 0.3
  */
-public interface BEXPair<T> {
+public interface BEXPair<T> extends Comparable<BEXPair<T>> {
 	/**
 	 * Gets the left value in the pair
 	 * @return the left value
@@ -256,4 +258,24 @@ public default void acceptWithSide(final BiConsumer<T, BEXSide> consumer) {
 	public default String toString(final String format) {
 		return String.format(format, this.getLeft(), this.getRight());
 	}
+
+	/**
+	 * Compares the BEXPair first by the left element then the right element
+	 * @throws ClassCastException if the entries do not implement Comparable or are not mutually Comparable
+	 */
+	@Override
+	public default int compareTo(final BEXPair<T> o) {
+		@SuppressWarnings("unchecked")
+		Comparable<? super T> left1 = (Comparable<? super T>) this.getLeft();
+
+		@SuppressWarnings("unchecked")
+		Comparable<? super T> right1 = (Comparable<? super T>) this.getRight();
+
+		int compare = left1.compareTo(o.getLeft());
+		if (compare != 0) {
+			return compare;
+		}
+
+		return right1.compareTo(o.getRight());
+	}
 }

BEXCodeCompare/src/main/java/info/codesaway/bex/BEXPairs.java

@@ -9,6 +9,18 @@ private BEXPairs() {
 		throw new UnsupportedOperationException();
 	}
 
+	/**
+	 *
+	 * @param <T> the type
+	 * @param left the left value
+	 * @param right the right value
+	 * @return a BEXPair with the specified left / right values
+	 * @since 0.10
+	 */
+	public static <T> BEXPair<T> bexPair(final T left, final T right) {
+		return new BEXPairValue<>(left, right);
+	}
+
 	public static <K, V> BEXPair<V> mapGet(final BEXPair<? extends Map<K, V>> mapPair,
 			final BEXPair<K> keyPair) {
 		return mapPair.mapWithSide((m, side) -> m.get(keyPair.get(side)));

BEXCodeCompare/src/main/java/info/codesaway/bex/IntBEXRange.java

@@ -29,6 +29,11 @@ private IntBEXRange(final int start, final int end, final boolean hasInclusiveEn
 		if (end < start) {
 			throw new IllegalArgumentException(String.format("Invalid range start = %d, end = %d", start, end));
 		}
+
+		if (end == start && !hasInclusiveStart && !hasInclusiveEnd) {
+			// Mimics Guava's Range class and throws exception
+			throw new IllegalArgumentException(String.format("Invalid range (%d, %d)", start, end));
+		}
 	}
 
 	/**

BEXCodeCompare/src/main/java/info/codesaway/bex/IntRange.java

@@ -38,6 +38,19 @@ public default boolean isEmpty() {
 				&& !(this.hasInclusiveStart() && this.hasInclusiveEnd());
 	}
 
+	/**
+	 *
+	 * @return the length of the range
+	 * @since 0.10
+	 */
+	public default int length() {
+		// Logic from canonical
+		int start = this.hasInclusiveStart() ? this.getStart() : this.getStart() + 1;
+		int end = this.hasInclusiveEnd() ? this.getEnd() + 1 : this.getEnd();
+
+		return end - start;
+	}
+
 	public default IntRange canonical() {
 		if (this.hasInclusiveStart() && !this.hasInclusiveEnd()) {
 			return this;

BEXCodeCompare/src/main/java/info/codesaway/bex/matching/BEXMatchResult.java

@@ -5,48 +5,107 @@
 import java.util.Map.Entry;
 import java.util.Set;
 
-import info.codesaway.bex.IntPair;
+import info.codesaway.bex.IntBEXRange;
 
 public interface BEXMatchResult {
 	public BEXPattern pattern();
 
 	public String text();
 
-	public IntPair startEndPair();
+	/**
+	 *
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
+	public IntBEXRange range();
 
+	/**
+	 *
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
 	public default int start() {
-		return this.startEndPair().getLeft();
+		return this.range().getStart();
 	}
 
+	/**
+	 *
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
 	public default int end() {
-		return this.startEndPair().getRight();
+		return this.range().getEnd();
 	}
 
+	/**
+	 *
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
 	public default String group() {
-		return getSubstring(this.text(), this.startEndPair());
+		return getSubstring(this.text(), this.range());
 	}
 
-	public IntPair startEndPair(String group);
+	/**
+	 *
+	 * @param group
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
+	public IntBEXRange range(String group);
 
+	/**
+	 *
+	 * @param group
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
 	public default int start(final String group) {
-		return this.startEndPair(group).getLeft();
+		return this.range(group).getStart();
 	}
 
+	/**
+	 *
+	 * @param group
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
 	public default int end(final String group) {
-		return this.startEndPair(group).getRight();
+		return this.range(group).getEnd();
 	}
 
+	/**
+	 *
+	 * @param group
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
 	public default String group(final String group) {
 		if (group.equals("*")) {
 			return this.group();
 		}
 
-		IntPair startEndPair = this.startEndPair(group);
-		if (startEndPair.getLeft() == -1 || startEndPair.getRight() == -1) {
+		IntBEXRange range = this.range(group);
+		if (range.getStart() == -1 || range.getEnd() == -1) {
 			return null;
 		}
 
-		return getSubstring(this.text(), startEndPair);
+		return getSubstring(this.text(), range);
 	}
 
 	/**
@@ -61,10 +120,20 @@ public default String group(final String group) {
 	 *
 	 * @throws IllegalArgumentException
 	 *             If the group is not specified in the pattern
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
 	 */
 	public default String get(final String group) {
 		return this.group(group);
 	}
 
+	/**
+	 *
+	 * @return
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
 	public Set<Entry<String, String>> entrySet();
 }

BEXCodeCompare/src/main/java/info/codesaway/bex/matching/BEXMatcher.java

@@ -61,7 +61,7 @@ public final class BEXMatcher implements BEXMatchResult {
 	 */
 	private int offset;
 
-	private final MutableIntBEXPair matchStartEnd = new MutableIntBEXPair(-1, 0);
+	private final MutableIntBEXPair matchRange = new MutableIntBEXPair(-1, 0);
 
 	/**
 	 * Most groups will have only one value, so stored here
@@ -105,7 +105,7 @@ public BEXPattern pattern() {
 	 */
 	public BEXMatchResult toMatchResult() {
 		BEXMatcher result = new BEXMatcher(this.pattern(), this.text(), this.textStateMap, this.offset);
-		result.matchStartEnd.set(this.matchStartEnd);
+		result.matchRange.set(this.matchRange);
 		result.valuesMap.putAll(this.valuesMap);
 
 		if (!this.multipleValuesMap.isEmpty()) {
@@ -129,8 +129,8 @@ private void clearGroups() {
 
 	public boolean find() {
 		// Logic from regex Matcher.find
-		int nextSearchStart = this.end();
-		if (nextSearchStart == this.start()) {
+		int nextSearchStart = this.matchRange.getRight();
+		if (nextSearchStart == this.matchRange.getLeft()) {
 			nextSearchStart++;
 		}
 		// If next search starts beyond region then it fails
@@ -148,7 +148,7 @@ private boolean search(final int from) {
 
 		boolean foundMatch = this.match(from);
 		if (!foundMatch) {
-			this.matchStartEnd.setLeft(-1);
+			this.matchRange.setLeft(-1);
 		}
 
 		return foundMatch;
@@ -362,13 +362,13 @@ private boolean match(final int from) {
 			// (unless it's an unnamed group)
 			if (!group.equals("_")) {
 				// TODO: what if group was matched as part of regex, does normal group have to match?
-				IntBEXRange startEnd = this.getInternal(group);
+				IntBEXRange range = this.getInternalNoMatchCheck(group);
 
 				// If group is already specified
-				if (startEnd != null && startEnd != NOT_FOUND) {
+				if (range != null && range != NOT_FOUND) {
 					// Verify the content equals; otherwise, don't match
 					// TODO: should go to next match or something... need to implement
-					int oldLength = startEnd.getRight() - startEnd.getLeft();
+					int oldLength = range.length();
 					int newLength = end - start;
 
 					// Fast check, based on length
@@ -377,7 +377,7 @@ private boolean match(final int from) {
 					}
 
 					// Compare character by character
-					int index1 = startEnd.getLeft();
+					int index1 = range.getStart();
 					int index2 = start;
 
 					for (int m = 0; m < oldLength; m++) {
@@ -402,10 +402,10 @@ private boolean match(final int from) {
 		int matchStart = currentMatcher.start();
 		int matchEnd = regionStart;
 
-		this.matchStartEnd.set(matchStart, matchEnd);
+		this.matchRange.set(matchStart, matchEnd);
 
 		if (DEBUG) {
-			System.out.println("Found match: " + this.matchStartEnd);
+			System.out.println("Found match: " + this.matchRange);
 		}
 
 		return true;
@@ -458,7 +458,7 @@ private BEXMatchingState search(final int start, final int end,
 			if (entry != null && !entry.getValue().isCode()) {
 				// Has a state option
 				IntRange canonical = entry.getKey().canonical();
-				boolean isEndOfRange = indexWithOffset == canonical.getRight() - 1;
+				boolean isEndOfRange = indexWithOffset == canonical.getEnd() - 1;
 
 				stateOption = isEndOfRange ? null : entry.getValue();
 
@@ -554,26 +554,33 @@ private void put(final String group, final IntBEXRange value) {
 	}
 
 	@Override
-	public IntBEXRange startEndPair() {
-		return IntBEXRange.of(this.matchStartEnd.getLeft(), this.matchStartEnd.getRight());
+	public IntBEXRange range() {
+		this.checkForMatch();
+
+		return IntBEXRange.of(this.matchRange.getLeft(), this.matchRange.getRight());
 	}
 
 	@Override
-	public IntBEXRange startEndPair(final String group) {
-		IntBEXRange startEnd = this.getInternal(group);
+	public IntBEXRange range(final String group) {
+		IntBEXRange range = this.getInternal(group);
 
 		// Intentionally using identity equals
-		if (startEnd == NOT_FOUND) {
+		if (range == NOT_FOUND) {
 			throw new IllegalArgumentException("The specified group is not in the pattern: " + group);
 		}
 
-		return startEnd;
+		return range;
 	}
 
 	private static IntBEXRange NOT_FOUND = IntBEXRange.of(Integer.MIN_VALUE, Integer.MIN_VALUE);
 	private static IntBEXRange NULL_PAIR = IntBEXRange.of(-1, -1);
 
 	private IntBEXRange getInternal(final String group) {
+		this.checkForMatch();
+		return this.getInternalNoMatchCheck(group);
+	}
+
+	private IntBEXRange getInternalNoMatchCheck(final String group) {
 		List<IntBEXRange> existingValues = this.multipleValuesMap.get(group);
 
 		if (existingValues != null) {
@@ -597,7 +604,7 @@ private IntBEXRange getInternal(final String group) {
 	 * @since 0.6
 	 */
 	public BEXMatcher reset() {
-		this.matchStartEnd.set(-1, 0);
+		this.matchRange.set(-1, 0);
 		this.clearGroups();
 		this.lastAppendPosition = 0;
 
@@ -921,6 +928,7 @@ public StringBuffer appendTail(final StringBuffer sb) {
 	 */
 	@Override
 	public Set<Entry<String, String>> entrySet() {
+		this.checkForMatch();
 		return new EntrySet();
 	}
 
@@ -933,6 +941,19 @@ private int getTextLength() {
 		return this.text.length();
 	}
 
+	/**
+	 * Check for match
+	 *
+	 * @throws  IllegalStateException
+	 *          If no match has yet been attempted,
+	 *          or if the previous match operation failed
+	 */
+	private void checkForMatch() {
+		if (this.matchRange.getLeft() < 0) {
+			throw new IllegalStateException("No match available");
+		}
+	}
+
 	/**
 	 * Returns a literal replacement <code>String</code> for the specified
 	 * <code>String</code>.