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;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 
 import  javax.annotation.Nullable;

Implementation detail for the internal structure of Range instances. Represents a unique way of "cutting" a "number line" (actually of instances of type C, not necessarily "numbers") into two sections; this can be done below a certain value, above a certain value, below all values or above all values. With this object defined in this way, an interval can always be represented by a pair of Cut instances.

Author(s):
Kevin Bourrillion
 
 abstract class Cut<C extends Comparableimplements Comparable<Cut<C>>, Serializable {
   final C endpoint;
 
   Cut(@Nullable C endpoint) {
     this. = endpoint;
   }
 
   abstract boolean isLessThan(C value);
 
   abstract BoundType typeAsLowerBound();
   abstract BoundType typeAsUpperBound();
 
   abstract Cut<C> withLowerBoundType(BoundType boundTypeDiscreteDomain<C> domain);
   abstract Cut<C> withUpperBoundType(BoundType boundTypeDiscreteDomain<C> domain);
 
   abstract void describeAsLowerBound(StringBuilder sb);
   abstract void describeAsUpperBound(StringBuilder sb);
 
   abstract C leastValueAbove(DiscreteDomain<C> domain);
   abstract C greatestValueBelow(DiscreteDomain<C> domain);
 
   /*
    * The canonical form is a BelowValue cut whenever possible, otherwise ABOVE_ALL, or
    * (only in the case of types that are unbounded below) BELOW_ALL.
    */
   Cut<C> canonical(DiscreteDomain<C> domain) {
     return this;
   }
 
   // note: overriden by {BELOW,ABOVE}_ALL
   @Override
   public int compareTo(Cut<C> that) {
     if (that == belowAll()) {
       return 1;
     }
     if (that == aboveAll()) {
       return -1;
     }
     int result = Range.compareOrThrow(that.endpoint);
     if (result != 0) {
       return result;
     }
     // same value. below comes before above
     return Booleans.compare(
         this instanceof AboveValuethat instanceof AboveValue);
   }
 
   C endpoint() {
     return ;
   }
 
   @SuppressWarnings("unchecked"// catching CCE
   @Override public boolean equals(Object obj) {
     if (obj instanceof Cut) {
       // It might not really be a Cut<C>, but we'll catch a CCE if it's not
       Cut<C> that = (Cut<C>) obj;
       try {
         int compareResult = compareTo(that);
         return compareResult == 0;
       } catch (ClassCastException ignored) {
       }
     }
     return false;
  }
  /*
   * The implementation neither produces nor consumes any non-null instance of type C, so
   * casting the type parameter is safe.
   */
  @SuppressWarnings("unchecked")
  static <C extends ComparableCut<C> belowAll() {
    return (Cut<C>) .;
  }
  private static final long serialVersionUID = 0;
  private static final class BelowAll extends Cut<Comparable<?>> {
    private static final BelowAll INSTANCE = new BelowAll();
    private BelowAll() {
      super(null);
    }
    @Override Comparable<?> endpoint() {
      throw new IllegalStateException("range unbounded on this side");
    }
    @Override boolean isLessThan(Comparable<?> value) {
      return true;
    }
      throw new IllegalStateException();
    }
      throw new AssertionError("this statement should be unreachable");
    }
        DiscreteDomain<Comparable<?>> domain) {
      throw new IllegalStateException();
    }
        DiscreteDomain<Comparable<?>> domain) {
      throw new AssertionError("this statement should be unreachable");
    }
      sb.append("(-\u221e");
    }
      throw new AssertionError();
    }
        DiscreteDomain<Comparable<?>> domain) {
      return domain.minValue();
    }
        DiscreteDomain<Comparable<?>> domain) {
      throw new AssertionError();
    }
        DiscreteDomain<Comparable<?>> domain) {
      try {
        return Cut.<Comparable<?>>belowValue(domain.minValue());
      } catch (NoSuchElementException e) {
        return this;
      }
    }
    @Override public int compareTo(Cut<Comparable<?>> o) {
      return (o == this) ? 0 : -1;
    }
    @Override public String toString() {
      return "-\u221e";
    }
    private Object readResolve() {
      return ;
    }
    private static final long serialVersionUID = 0;
  }
  /*
   * The implementation neither produces nor consumes any non-null instance of
   * type C, so casting the type parameter is safe.
   */
  @SuppressWarnings("unchecked")
  static <C extends ComparableCut<C> aboveAll() {
    return (Cut<C>) .;
  }
  private static final class AboveAll extends Cut<Comparable<?>> {
    private static final AboveAll INSTANCE = new AboveAll();
    private AboveAll() {
      super(null);
    }
    @Override Comparable<?> endpoint() {
      throw new IllegalStateException("range unbounded on this side");
    }
    @Override boolean isLessThan(Comparable<?> value) {
      return false;
    }
      throw new AssertionError("this statement should be unreachable");
    }
      throw new IllegalStateException();
    }
        DiscreteDomain<Comparable<?>> domain) {
      throw new AssertionError("this statement should be unreachable");
    }
        DiscreteDomain<Comparable<?>> domain) {
      throw new IllegalStateException();
    }
      throw new AssertionError();
    }
      sb.append("+\u221e)");
    }
        DiscreteDomain<Comparable<?>> domain) {
      throw new AssertionError();
    }
        DiscreteDomain<Comparable<?>> domain) {
      return domain.maxValue();
    }
    @Override public int compareTo(Cut<Comparable<?>> o) {
      return (o == this) ? 0 : 1;
    }
    @Override public String toString() {
      return "+\u221e";
    }
    private Object readResolve() {
      return ;
    }
    private static final long serialVersionUID = 0;
  }
  static <C extends ComparableCut<C> belowValue(C endpoint) {
    return new BelowValue<C>(endpoint);
  }
  private static final class BelowValue<C extends Comparableextends Cut<C> {
    BelowValue(C endpoint) {
      super(checkNotNull(endpoint));
    }
    @Override boolean isLessThan(C value) {
      return Range.compareOrThrow(value) <= 0;
    }
      return .;
    }
      return .;
    }
    @Override Cut<C> withLowerBoundType(BoundType boundTypeDiscreteDomain<C> domain) {
      switch (boundType) {
        case :
          return this;
        case :
          @Nullable C previous = domain.previous();
          return (previous == null) ? Cut.<C>belowAll() : new AboveValue<C>(previous);
        default:
          throw new AssertionError();
      }
    }
    @Override Cut<C> withUpperBoundType(BoundType boundTypeDiscreteDomain<C> domain) {
      switch (boundType) {
        case :
          @Nullable C previous = domain.previous();
          return (previous == null) ? Cut.<C>aboveAll() : new AboveValue<C>(previous);
        case :
          return this;
        default:
          throw new AssertionError();
      }
    }
      sb.append('[').append();
    }
      sb.append().append(')');
    }
    @Override C leastValueAbove(DiscreteDomain<C> domain) {
      return ;
    }
    @Override C greatestValueBelow(DiscreteDomain<C> domain) {
      return domain.previous();
    }
    @Override public int hashCode() {
      return .hashCode();
    }
    @Override public String toString() {
      return "\\" +  + "/";
    }
    private static final long serialVersionUID = 0;
  }
  static <C extends ComparableCut<C> aboveValue(C endpoint) {
    return new AboveValue<C>(endpoint);
  }
  private static final class AboveValue<C extends Comparableextends Cut<C> {
    AboveValue(C endpoint) {
      super(checkNotNull(endpoint));
    }
    @Override boolean isLessThan(C value) {
      return Range.compareOrThrow(value) < 0;
    }
      return .;
    }
      return .;
    }
    @Override Cut<C> withLowerBoundType(BoundType boundTypeDiscreteDomain<C> domain) {
      switch (boundType) {
        case :
          return this;
        case :
          @Nullable C next = domain.next();
          return (next == null) ? Cut.<C>belowAll() : belowValue(next);
        default:
          throw new AssertionError();
      }
    }
    @Override Cut<C> withUpperBoundType(BoundType boundTypeDiscreteDomain<C> domain) {
      switch (boundType) {
        case :
          @Nullable C next = domain.next();
          return (next == null) ? Cut.<C>aboveAll() : belowValue(next);
        case :
          return this;
        default:
          throw new AssertionError();
      }
    }
      sb.append('(').append();
    }
      sb.append().append(']');
    }
    @Override C leastValueAbove(DiscreteDomain<C> domain) {
      return domain.next();
    }
    @Override C greatestValueBelow(DiscreteDomain<C> domain) {
      return ;
    }
    @Override Cut<C> canonical(DiscreteDomain<C> domain) {
      C next = leastValueAbove(domain);
      return (next != null) ? belowValue(next) : Cut.<C>aboveAll();
    }
    @Override public int hashCode() {
      return ~.hashCode();
    }
    @Override public String toString() {
      return "/" +  + "\\";
    }
    private static final long serialVersionUID = 0;
  }
New to GrepCode? Check out our FAQ X