/*

  Copyright 2004-2008 Paul R. Holser, Jr.  All rights reserved.

  Licensed under the Academic Free License version 3.0

  */

 package jaggregate;

 import java.util.Comparator;

 import static java.lang.String.*;

 /**

  * Utility class that offers useful operations on {@linkplain Comparable Comparables}.

  *

  * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>

  * @version $Id: Comparables.java,v 1.7 2008/08/09 04:35:29 pholser Exp $

  */

 public class Comparables {

     /**

      * Discourages instantiation.

      *

      * @throws UnsupportedOperationException always

      */

     protected Comparables() {

         throw new UnsupportedOperationException();

     }

     /**

      * Answers a predicate which will answer {@code true} if its argument compares

      * "less than" the given comparand.

      * <p/>

      * For purposes of this comparison, {@code null} always compares "less than"

      * non-{@code null}.

      *

      * @param <E> a constraint on the type of the comparand

      * @param comparand the comparand to use with the returned predicate

      * @return a predicate that can be used to compare arguments with {@code comparand}

      */

     public static <E extends Comparable<? super E>> UnaryPredicate<E> lessThan(

         E comparand ) {

         return new LessThan<E>().bindSecond( comparand );

     }

     /**

      * Answers a predicate which will answer {@code true} if its argument compares

      * "less than" or "equal to" the given comparand.

      * <p/>

      * For purposes of this comparison, {@code null} always compares "less than"

      * non-{@code null}.

      *

      * @param <E> a constraint on the type of the comparand

      * @param comparand the comparand to use with the returned predicate

      * @return a predicate that can be used to compare arguments with {@code comparand}

      */

     public static <E extends Comparable<? super E>> UnaryPredicate<E> lessThanOrEqualTo(

         E comparand ) {

         return new LessThanOrEqualTo<E>().bindSecond( comparand );

     }

     /**

      * Answers a predicate which will answer {@code true} if its argument compares

      * "greater than" the given comparand.

      * <p/>

      * For purposes of this comparison, {@code null} always compares "less than"

      * non-{@code null}.

      *

      * @param <E> a constraint on the type of the comparand

      * @param comparand the comparand to use with the returned predicate

      * @return a predicate that can be used to compare arguments with {@code comparand}

      */

     public static <E extends Comparable<? super E>> UnaryPredicate<E> greaterThan(

         E comparand ) {

         return new GreaterThan<E>().bindSecond( comparand );

     }

     /**

      * Answers a predicate which will answer {@code true} if its argument compares

      * "greater than" or "equal to" the given comparand.

      * <p/>

      * For purposes of this comparison, {@code null} always compares "less than"

      * non-{@code null}.

      *

      * @param <E> a constraint on the type of the comparand

      * @param comparand the comparand to use with the returned predicate

      * @return a predicate that can be used to compare arguments with {@code comparand}

      */

     public static <E extends Comparable<? super E>>

     UnaryPredicate<E> greaterThanOrEqualTo( E comparand ) {

         return new GreaterThanOrEqualTo<E>().bindSecond( comparand );

     }

     /**

      * Answers a predicate which will answer {@code true} if its argument compares

      * "between" the given minimum and maximum, inclusive.

      * <p/>

      * For purposes of this comparison, {@code null} always compares "less than"

      * non-{@code null}.

      *

      * @param <E> a constraint on the type of the bounds

      * @param minimum the lower bound

      * @param maximum the upper bound

      * @return a predicate that can be used to compare arguments with {@code minimum}

      *         and {@code maximum}

      */

     public static <E extends Comparable<? super E>> UnaryPredicate<E> between( E minimum,

         E maximum ) {

         return new Between<E>( minimum, maximum );

     }

     /**

      * Answers a function which will give the greater of its two arguments.

      * <p/>

      * For purposes of this comparison, {@code null} always compares "less than"

      * non-{@code null}.

      *

      * @param <E> a constraint on the types of the function's arguments

      * @return function which will give the greater of its two arguments

      */

     public static <E extends Comparable<? super E>> BinaryFunction<E, E, E> max() {

         return new Max<E>();

     }

     /**

      * Answers a function which will give the lesser of its two arguments.

      * <p/>

      * For purposes of this comparison, {@code null} always compares "less than"

      * non-{@code null}.

      *

      * @param <E> a constraint on the types of the function's arguments

      * @return function which will give the lesser of its two arguments

      */

     public static <E extends Comparable<? super E>> BinaryFunction<E, E, E> min() {

         return new Min<E>();

     }

     private abstract static

     class NaturalOrderingPredicate<E extends Comparable<? super E>>

         extends BinaryPredicate<E, E> {

         protected static final String LESS_THAN_FORMAT = "a value less than <%1$s>";

         protected static final String GREATER_THAN_FORMAT = "a value greater than <%1$s>";

         protected static final String LESS_THAN_OR_EQUAL_TO_FORMAT =

             "a value less than or equal to <%1$s>";

         protected static final String GREATER_THAN_OR_EQUAL_TO_FORMAT =

             "a value greater than or equal to <%1$s>";

         protected final Comparator<E> comparator;

         protected NaturalOrderingPredicate() {

             comparator = Comparing.<E>byNaturalOrdering();

         }

     }

     private static class LessThan<E extends Comparable<? super E>>

         extends NaturalOrderingPredicate<E> {

         public boolean matches( E first, E second ) {

             return comparator.compare( first, second ) < 0;

         }

         @Override

         protected String getSecondBoundDescription() {

             return LESS_THAN_FORMAT;

         }

     }

     private static class LessThanOrEqualTo<E extends Comparable<? super E>>

         extends NaturalOrderingPredicate<E> {

         public boolean matches( E first, E second ) {

             return comparator.compare( first, second ) <= 0;

         }

         @Override

         protected String getSecondBoundDescription() {

             return LESS_THAN_OR_EQUAL_TO_FORMAT;

         }

     }

     private static class GreaterThan<E extends Comparable<? super E>>

         extends NaturalOrderingPredicate<E> {

         public boolean matches( E first, E second ) {

             return comparator.compare( first, second ) > 0;

         }

         @Override

         protected String getSecondBoundDescription() {

             return GREATER_THAN_FORMAT;

         }

     }

     private static class GreaterThanOrEqualTo<E extends Comparable<? super E>>

         extends NaturalOrderingPredicate<E> {

         public boolean matches( E first, E second ) {

             return comparator.compare( first, second ) >= 0;

         }

         @Override

         protected String getSecondBoundDescription() {

             return GREATER_THAN_OR_EQUAL_TO_FORMAT;

         }

     }

     private static class Between<E extends Comparable<? super E>>

         extends UnaryPredicate<E> {

         private final E first;

         private final E second;

         Between( E first, E second ) {

             this.first = first;

             this.second = second;

         }

         public boolean matches( E target ) {

             Comparator<E> comparator = Comparing.<E>byNaturalOrdering();

             return comparator.compare( first, target ) <= 0

                 && comparator.compare( target, second ) <= 0;

         }

         @Override

         public String describe() {

             return format( "a value between <%1$s> and <%2$s>", first, second );

         }

     }

     private static class Max<E extends Comparable<? super E>>

         extends BinaryFunction<E, E, E> {

         private final Comparator<E> comparator = Comparing.<E>byNaturalOrdering();

         public E evaluate( E first, E second ) {

             return comparator.compare( first, second ) >= 0 ? first : second;

         }

     }

     private static class Min<E extends Comparable<? super E>>

         extends BinaryFunction<E, E, E> {

         private final Comparator<E> comparator = Comparing.<E>byNaturalOrdering();

         public E evaluate( E first, E second ) {

             return comparator.compare( first, second ) <= 0 ? first : second;

         }

     }

 }