source: trunk/src/org/expeditee/core/Range.java@ 1441

package org.expeditee.core;

/**
 * Represents a range of ordered values defined by a start and end value.
 * Range can be open or closed at each end (i.e. the start and end points
 * can be considered inside or outside the range). Either/both ends can
 * also be null representing no lower/upper bound. If the upper bound is
 * lower than the lower bound, the range is an outside range (where points
 * outside the two bounds are considered contained by the range).
 * 
 * @author cts16
 *
 * @param <T> The type of values in this range. Must have an order and
 *                              therefore must implement Comparable. 
 */
public class Range<T extends Comparable<T>> {

        /** The lowest value in the range. If null, then the range has no lower bound. */
        public T lowerBound;
        /** The highest value in the range. If null, then the range has no upper bound. */
        public T upperBound;
        /** Whether the lowest value is open or closed (outside or inside the range respectively). */
        public boolean lowerBoundClosed;
        /** Whether the end value is open or closed. */
        public boolean upperBoundClosed;
        
        /** Standard constructor considers the lower bound closed and upper bound open. */
        public Range(T lowerBound, T upperBound)
        {
                this(lowerBound, upperBound, true, false);
        }
        
        /** Standard constructor. */
        public Range(T lowerBound, T upperBound, boolean lowerBoundClosed, boolean upperBoundClosed)
        {
                this.lowerBound = lowerBound;
                this.upperBound = upperBound;
                this.lowerBoundClosed = lowerBoundClosed;
                this.upperBoundClosed = upperBoundClosed;
        }
        
        /** Whether this range contains the given value. */
        public boolean contains(T t)
        {
                // A null value is never inside the bound
                if (t == null) return false;
                
                // See how the value compares to the two boundaries
                int compStart = lowerBound != null ? t.compareTo(lowerBound) : 0;
                int compEnd = upperBound != null ? t.compareTo(upperBound) : 0;
                
                // See if this is an outside range
                boolean outsideRange = lowerBound != null && upperBound != null && upperBound.compareTo(lowerBound) < 0;
                
                // Make sure it's above the lower bound
                boolean aboveLowerBound =       (lowerBound == null) || // No lower bound, or...
                                                                        (compStart > 0) || // Strictly above the lower bound, or...
                                                                        (compStart == 0 && lowerBoundClosed); // On the lower bound but it's closed
                
                // Make sure it's below the upper bound
                boolean belowUpperBound =       (upperBound == null) || // No upper bound, or...
                                                                        (compEnd < 0) || // Strictly below the upper bound, or...
                                                                        (compEnd == 0 && upperBoundClosed); // On the upper bound but it's closed
                
                // In an inside range if we are below the upper bound and above the lower bound,
                // in an outside range if we are below the upper bound or above the lower bound
                return  (aboveLowerBound && belowUpperBound) ||
                                (outsideRange && (aboveLowerBound || belowUpperBound));
        }
        
        /** Creates an inside range when the order of the two ends is unknown. Both ends are considered closed. */
        public static <T extends Comparable<T>> Range<T> insideRangeFromUncertainEnds(T anEnd, T anotherEnd)
        {
                return insideRangeFromUncertainEnds(anEnd, anotherEnd, true, true);
        }
        
        /** Creates an inside range when the order of the two ends is unknown. */
        public static <T extends Comparable<T>> Range<T> insideRangeFromUncertainEnds(T anEnd, T anotherEnd, boolean anEndClosed, boolean anotherEndClosed)
        {
                // If both ends are null then ordering doesn't matter
                if (anEnd == null && anotherEnd == null) return new Range<T>(anEnd, anotherEnd, anEndClosed, anotherEndClosed);
                
                // Can't determine order of a single end
                if (anEnd == null || anotherEnd == null) return null;
                
                // Put the two ends in order (so anEnd is lower than anotherEnd),
                // keeping the respective closed flags with their ends
                if (anEnd.compareTo(anotherEnd) > 0) {
                        T temp = anEnd;
                        anEnd = anotherEnd;
                        anotherEnd = temp;
                        boolean bTemp = anEndClosed;
                        anEndClosed = anotherEndClosed;
                        anotherEndClosed = bTemp;
                }
                
                // Create a range from the reorder ends
                return new Range<T>(anEnd, anotherEnd, anEndClosed, anotherEndClosed);
        }
}