Coverage Report - org.apache.commons.functor.core.comparator.IsNotEquivalent
 
Classes in this File Line Coverage Branch Coverage Complexity
IsNotEquivalent
85%
18/21
62%
10/16
1.889
 
 1   
 /*
 2   
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3   
  * contributor license agreements.  See the NOTICE file distributed with
 4   
  * this work for additional information regarding copyright ownership.
 5   
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6   
  * (the "License"); you may not use this file except in compliance with
 7   
  * the License.  You may obtain a copy of the License at
 8   
  *
 9   
  *      http://www.apache.org/licenses/LICENSE-2.0
 10   
  *
 11   
  * Unless required by applicable law or agreed to in writing, software
 12   
  * distributed under the License is distributed on an "AS IS" BASIS,
 13   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14   
  * See the License for the specific language governing permissions and
 15   
  * limitations under the License.
 16   
  */
 17   
 package org.apache.commons.functor.core.comparator;
 18   
 
 19   
 import java.io.Serializable;
 20   
 import java.util.Comparator;
 21   
 
 22   
 import org.apache.commons.functor.BinaryPredicate;
 23   
 import org.apache.commons.functor.UnaryPredicate;
 24   
 import org.apache.commons.functor.adapter.RightBoundPredicate;
 25   
 
 26   
 /**
 27   
  * A {@link BinaryPredicate BinaryPredicate} that {@link #test tests}
 28   
  * <code>true</code> iff the left argument is not equal to the
 29   
  * right argument under the specified {@link Comparator}.
 30   
  * When no (or a <code>null</code> <code>Comparator</code> is specified,
 31   
  * a {@link Comparable Comparable} <code>Comparator</code> is used.
 32   
  *
 33   
  * @see org.apache.commons.functor.core.IsEqual
 34   
  *
 35   
  * @version $Revision: 1166347 $ $Date: 2011-09-07 21:48:35 +0200 (Wed, 07 Sep 2011) $
 36   
  * @author Rodney Waldhoff
 37   
  *
 38   
  */
 39   
 public final class IsNotEquivalent<T> implements BinaryPredicate<T, T>, Serializable {
 40   
 
 41   
     /**
 42   
      * Basic IsNotEquivalent instance.
 43   
      */
 44  2 
     public static final IsNotEquivalent<Comparable<?>> INSTANCE = IsNotEquivalent.<Comparable<?>>instance();
 45   
 
 46   
     /**
 47   
      * serialVersionUID declaration.
 48   
      */
 49   
     private static final long serialVersionUID = 1021154684877529051L;
 50   
 
 51   
     private final Comparator<? super T> comparator;
 52   
 
 53   
     /**
 54   
      * Create a new IsNotEquivalent.
 55   
      */
 56   
     @SuppressWarnings("unchecked")
 57   
     public IsNotEquivalent() {
 58  4 
         this(ComparableComparator.INSTANCE);
 59  4 
     }
 60   
 
 61   
     /**
 62   
      * Construct a <code>IsNotEquivalent</code> {@link BinaryPredicate predicate}
 63   
      * for the given {@link Comparator Comparator}.
 64   
      *
 65   
      * @param comparator the {@link Comparator Comparator}, when <code>null</code>,
 66   
      *        a <code>Comparator</code> for {@link Comparable Comparable}s will
 67   
      *        be used.
 68   
      */
 69  26 
     public IsNotEquivalent(Comparator<? super T> comparator) {
 70  26 
         if (comparator == null) {
 71  0 
             throw new IllegalArgumentException("Comparator must not be null");
 72   
         }
 73  26 
         this.comparator = comparator;
 74  26 
     }
 75   
 
 76   
     /**
 77   
      * {@inheritDoc}
 78   
      * Return <code>true</code> iff the <i>left</i> parameter is
 79   
      * not equal to the <i>right</i> parameter under my current
 80   
      * {@link Comparator Comparator}.
 81   
      */
 82   
     public boolean test(T left, T right) {
 83  26 
         return comparator.compare(left, right) != 0;
 84   
     }
 85   
 
 86   
     /**
 87   
      * {@inheritDoc}
 88   
      */
 89   
     public boolean equals(Object that) {
 90  22 
         return that == this || (that instanceof IsNotEquivalent<?> && equals((IsNotEquivalent<?>) that));
 91   
     }
 92   
 
 93   
     /**
 94   
      * Learn whether another IsNotEquivalent is equal to this.
 95   
      * @param that IsNotEquivalent to test
 96   
      * @return boolean
 97   
      */
 98   
     public boolean equals(IsNotEquivalent<?> that) {
 99  14 
         if (null != that) {
 100  14 
             if (null == comparator) {
 101  0 
                 return null == that.comparator;
 102   
             }
 103  14 
             return comparator.equals(that.comparator);
 104   
         }
 105  0 
         return false;
 106   
     }
 107   
 
 108   
     /**
 109   
      * {@inheritDoc}
 110   
      */
 111   
     public int hashCode() {
 112  24 
         int hash = "IsNotEquivalent".hashCode();
 113   
         // by construction, comparator is never null
 114  24 
         hash ^= comparator.hashCode();
 115  24 
         return hash;
 116   
     }
 117   
 
 118   
     /**
 119   
      * {@inheritDoc}
 120   
      */
 121   
     public String toString() {
 122  16 
         return "IsNotEquivalent<" + comparator + ">";
 123   
     }
 124   
 
 125   
     /**
 126   
      * Get an IsNotEquivalent instance.
 127   
      * @return IsNotEquivalent
 128   
      */
 129   
     @SuppressWarnings("unchecked")
 130   
     public static <T extends Comparable<?>> IsNotEquivalent<T> instance() {
 131  20 
         return new IsNotEquivalent<T>(ComparableComparator.INSTANCE);
 132   
     }
 133   
 
 134   
     /**
 135   
      * Get an IsNotEquivalent UnaryPredicate.
 136   
      * @param right Comparable against which UnaryPredicate arguments will be compared.
 137   
      * @return UnaryPredicate
 138   
      */
 139   
     public static <T extends Comparable<?>> UnaryPredicate<T> instance(T right) {
 140  4 
         return RightBoundPredicate.bind(instance(), right);
 141   
     }
 142   
 
 143   
 }
Report generated by Cobertura 1.9.4.1 on 9/15/11 10:50 PM.