Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.collect;
 
 
 
A utility for performing a chained comparison statement. For example:
   public int compareTo(Foo that) {
     return ComparisonChain.start()
         .compare(this.aString, that.aString)
         .compare(this.anInt, that.anInt)
         .compare(this.anEnum, that.anEnum, Ordering.natural().nullsLast())
         .result();
   }

The value of this expression will have the same sign as the first nonzero comparison result in the chain, or will be zero if every comparison result was zero.

Performance note: Even though the ComparisonChain caller always invokes its compare methods unconditionally, the ComparisonChain implementation stops calling its inputs' java.lang.Comparable.compareTo(java.lang.Object) and compare methods as soon as one of them returns a nonzero result. This optimization is typically important only in the presence of expensive compareTo and compare implementations.

See the Guava User Guide article on ComparisonChain.

Author(s):
Mark Davis
Kevin Bourrillion
Since:
2.0
 
 public abstract class ComparisonChain {
   private ComparisonChain() {}

  
Begins a new chained comparison statement. See example in the class documentation.
 
   public static ComparisonChain start() {
     return ;
   }
 
   private static final ComparisonChain ACTIVE = new ComparisonChain() {
     @SuppressWarnings("unchecked")
     @Override public ComparisonChain compare(
         Comparable leftComparable right) {
       return classify(left.compareTo(right));
     }
     @Override public <T> ComparisonChain compare(
         @Nullable T left, @Nullable T rightComparator<T> comparator) {
       return classify(comparator.compare(leftright));
     }
     @Override public ComparisonChain compare(int leftint right) {
       return classify(Ints.compare(leftright));
     }
     @Override public ComparisonChain compare(long leftlong right) {
       return classify(Longs.compare(leftright));
     }
     @Override public ComparisonChain compare(float leftfloat right) {
       return classify(Float.compare(leftright));
     }
     @Override public ComparisonChain compare(double leftdouble right) {
       return classify(Double.compare(leftright));
     }
     @Override public ComparisonChain compareTrueFirst(boolean leftboolean right) {
       return classify(Booleans.compare(rightleft)); // reversed
     }
     @Override public ComparisonChain compareFalseFirst(boolean leftboolean right) {
       return classify(Booleans.compare(leftright));
     }
    ComparisonChain classify(int result) {
      return (result < 0) ?  : (result > 0) ?  : ;
    }
    @Override public int result() {
      return 0;
    }
  };
  private static final ComparisonChain LESS = new InactiveComparisonChain(-1);
  private static final ComparisonChain GREATER = new InactiveComparisonChain(1);
  private static final class InactiveComparisonChain extends ComparisonChain {
    final int result;
    InactiveComparisonChain(int result) {
      this. = result;
    }
    @Override public ComparisonChain compare(
        @Nullable Comparable left, @Nullable Comparable right) {
      return this;
    }
    @Override public <T> ComparisonChain compare(@Nullable T left,
        @Nullable T right, @Nullable Comparator<T> comparator) {
      return this;
    }
    @Override public ComparisonChain compare(int leftint right) {
      return this;
    }
    @Override public ComparisonChain compare(long leftlong right) {
      return this;
    }
    @Override public ComparisonChain compare(float leftfloat right) {
      return this;
    }
    @Override public ComparisonChain compare(double leftdouble right) {
      return this;
    }
    @Override public ComparisonChain compareTrueFirst(boolean leftboolean right) {
      return this;
    }
    @Override public ComparisonChain compareFalseFirst(boolean leftboolean right) {
      return this;
    }
    @Override public int result() {
      return ;
    }
  }

  
Compares two comparable objects as specified by java.lang.Comparable.compareTo(java.lang.Object), if the result of this comparison chain has not already been determined.
  public abstract ComparisonChain compare(
      Comparable<?> leftComparable<?> right);

  
Compares two objects using a comparator, if the result of this comparison chain has not already been determined.
  public abstract <T> ComparisonChain compare(
      @Nullable T left, @Nullable T rightComparator<T> comparator);

  
Compares two int values as specified by com.google.common.primitives.Ints.compare(int,int), if the result of this comparison chain has not already been determined.
  public abstract ComparisonChain compare(int leftint right);

  
Compares two long values as specified by com.google.common.primitives.Longs.compare(long,long), if the result of this comparison chain has not already been determined.
  public abstract ComparisonChain compare(long leftlong right);

  
Compares two float values as specified by java.lang.Float.compare(float,float), if the result of this comparison chain has not already been determined.
  public abstract ComparisonChain compare(float leftfloat right);

  
Compares two double values as specified by java.lang.Double.compare(double,double), if the result of this comparison chain has not already been determined.
  public abstract ComparisonChain compare(double leftdouble right);

  
Compares two boolean values, considering true to be less than false, if the result of this comparison chain has not already been determined.

Since:
12.0
  public abstract ComparisonChain compareTrueFirst(boolean leftboolean right);

  
Compares two boolean values, considering false to be less than true, if the result of this comparison chain has not already been determined.

Since:
12.0 (present as compare since 2.0)
  public abstract ComparisonChain compareFalseFirst(boolean leftboolean right);

  
Ends this comparison chain and returns its result: a value having the same sign as the first nonzero comparison result in the chain, or zero if every result was zero.
  public abstract int result();
New to GrepCode? Check out our FAQ X