460 lines
11 KiB
Java
460 lines
11 KiB
Java
|
/*
|
||
|
|
* 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 java.io.Serializable;
|
||
|
|
import java.util.NoSuchElementException;
|
||
|
|
|
||
|
|
import javax.annotation.Nullable;
|
||
|
|
|
||
|
|
import com.google.common.annotations.GwtCompatible;
|
||
|
|
import com.google.common.primitives.Booleans;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Implementation detail for the internal structure of {@link Range} instances.
|
||
|
|
* Represents a unique way of "cutting" a "number line" (actually of instances
|
||
|
|
* of type {@code 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 {@code Cut} instances.
|
||
|
|
*
|
||
|
|
* @author Kevin Bourrillion
|
||
|
|
*/
|
||
|
|
@GwtCompatible
|
||
|
|
abstract class Cut<C extends Comparable> implements Comparable<Cut<C>>, Serializable {
|
||
|
|
final C endpoint;
|
||
|
|
|
||
|
|
Cut(@Nullable C endpoint) {
|
||
|
|
this.endpoint = endpoint;
|
||
|
|
}
|
||
|
|
|
||
|
|
abstract boolean isLessThan(C value);
|
||
|
|
|
||
|
|
abstract BoundType typeAsLowerBound();
|
||
|
|
|
||
|
|
abstract BoundType typeAsUpperBound();
|
||
|
|
|
||
|
|
abstract Cut<C> withLowerBoundType(BoundType boundType, DiscreteDomain<C> domain);
|
||
|
|
|
||
|
|
abstract Cut<C> withUpperBoundType(BoundType boundType, DiscreteDomain<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(endpoint, that.endpoint);
|
||
|
|
if (result != 0) {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
// same value. below comes before above
|
||
|
|
return Booleans.compare(this instanceof AboveValue, that instanceof AboveValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
C endpoint() {
|
||
|
|
return endpoint;
|
||
|
|
}
|
||
|
|
|
||
|
|
@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 Comparable> Cut<C> belowAll() {
|
||
|
|
return (Cut<C>) BelowAll.INSTANCE;
|
||
|
|
}
|
||
|
|
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsLowerBound() {
|
||
|
|
throw new IllegalStateException();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsUpperBound() {
|
||
|
|
throw new AssertionError("this statement should be unreachable");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<Comparable<?>> withLowerBoundType(BoundType boundType, DiscreteDomain<Comparable<?>> domain) {
|
||
|
|
throw new IllegalStateException();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<Comparable<?>> withUpperBoundType(BoundType boundType, DiscreteDomain<Comparable<?>> domain) {
|
||
|
|
throw new AssertionError("this statement should be unreachable");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsLowerBound(StringBuilder sb) {
|
||
|
|
sb.append("(-\u221e");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsUpperBound(StringBuilder sb) {
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Comparable<?> leastValueAbove(DiscreteDomain<Comparable<?>> domain) {
|
||
|
|
return domain.minValue();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Comparable<?> greatestValueBelow(DiscreteDomain<Comparable<?>> domain) {
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<Comparable<?>> canonical(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 INSTANCE;
|
||
|
|
}
|
||
|
|
|
||
|
|
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 Comparable> Cut<C> aboveAll() {
|
||
|
|
return (Cut<C>) AboveAll.INSTANCE;
|
||
|
|
}
|
||
|
|
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsLowerBound() {
|
||
|
|
throw new AssertionError("this statement should be unreachable");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsUpperBound() {
|
||
|
|
throw new IllegalStateException();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<Comparable<?>> withLowerBoundType(BoundType boundType, DiscreteDomain<Comparable<?>> domain) {
|
||
|
|
throw new AssertionError("this statement should be unreachable");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<Comparable<?>> withUpperBoundType(BoundType boundType, DiscreteDomain<Comparable<?>> domain) {
|
||
|
|
throw new IllegalStateException();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsLowerBound(StringBuilder sb) {
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsUpperBound(StringBuilder sb) {
|
||
|
|
sb.append("+\u221e)");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Comparable<?> leastValueAbove(DiscreteDomain<Comparable<?>> domain) {
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Comparable<?> greatestValueBelow(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 INSTANCE;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final long serialVersionUID = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static <C extends Comparable> Cut<C> belowValue(C endpoint) {
|
||
|
|
return new BelowValue<C>(endpoint);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final class BelowValue<C extends Comparable> extends Cut<C> {
|
||
|
|
BelowValue(C endpoint) {
|
||
|
|
super(checkNotNull(endpoint));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
boolean isLessThan(C value) {
|
||
|
|
return Range.compareOrThrow(endpoint, value) <= 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsLowerBound() {
|
||
|
|
return BoundType.CLOSED;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsUpperBound() {
|
||
|
|
return BoundType.OPEN;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<C> withLowerBoundType(BoundType boundType, DiscreteDomain<C> domain) {
|
||
|
|
switch (boundType) {
|
||
|
|
case CLOSED:
|
||
|
|
return this;
|
||
|
|
case OPEN:
|
||
|
|
@Nullable
|
||
|
|
C previous = domain.previous(endpoint);
|
||
|
|
return (previous == null) ? Cut.<C>belowAll() : new AboveValue<C>(previous);
|
||
|
|
default:
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<C> withUpperBoundType(BoundType boundType, DiscreteDomain<C> domain) {
|
||
|
|
switch (boundType) {
|
||
|
|
case CLOSED:
|
||
|
|
@Nullable
|
||
|
|
C previous = domain.previous(endpoint);
|
||
|
|
return (previous == null) ? Cut.<C>aboveAll() : new AboveValue<C>(previous);
|
||
|
|
case OPEN:
|
||
|
|
return this;
|
||
|
|
default:
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsLowerBound(StringBuilder sb) {
|
||
|
|
sb.append('[').append(endpoint);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsUpperBound(StringBuilder sb) {
|
||
|
|
sb.append(endpoint).append(')');
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
C leastValueAbove(DiscreteDomain<C> domain) {
|
||
|
|
return endpoint;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
C greatestValueBelow(DiscreteDomain<C> domain) {
|
||
|
|
return domain.previous(endpoint);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int hashCode() {
|
||
|
|
return endpoint.hashCode();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String toString() {
|
||
|
|
return "\\" + endpoint + "/";
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final long serialVersionUID = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static <C extends Comparable> Cut<C> aboveValue(C endpoint) {
|
||
|
|
return new AboveValue<C>(endpoint);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final class AboveValue<C extends Comparable> extends Cut<C> {
|
||
|
|
AboveValue(C endpoint) {
|
||
|
|
super(checkNotNull(endpoint));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
boolean isLessThan(C value) {
|
||
|
|
return Range.compareOrThrow(endpoint, value) < 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsLowerBound() {
|
||
|
|
return BoundType.OPEN;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
BoundType typeAsUpperBound() {
|
||
|
|
return BoundType.CLOSED;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<C> withLowerBoundType(BoundType boundType, DiscreteDomain<C> domain) {
|
||
|
|
switch (boundType) {
|
||
|
|
case OPEN:
|
||
|
|
return this;
|
||
|
|
case CLOSED:
|
||
|
|
@Nullable
|
||
|
|
C next = domain.next(endpoint);
|
||
|
|
return (next == null) ? Cut.<C>belowAll() : belowValue(next);
|
||
|
|
default:
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<C> withUpperBoundType(BoundType boundType, DiscreteDomain<C> domain) {
|
||
|
|
switch (boundType) {
|
||
|
|
case OPEN:
|
||
|
|
@Nullable
|
||
|
|
C next = domain.next(endpoint);
|
||
|
|
return (next == null) ? Cut.<C>aboveAll() : belowValue(next);
|
||
|
|
case CLOSED:
|
||
|
|
return this;
|
||
|
|
default:
|
||
|
|
throw new AssertionError();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsLowerBound(StringBuilder sb) {
|
||
|
|
sb.append('(').append(endpoint);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void describeAsUpperBound(StringBuilder sb) {
|
||
|
|
sb.append(endpoint).append(']');
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
C leastValueAbove(DiscreteDomain<C> domain) {
|
||
|
|
return domain.next(endpoint);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
C greatestValueBelow(DiscreteDomain<C> domain) {
|
||
|
|
return endpoint;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
Cut<C> canonical(DiscreteDomain<C> domain) {
|
||
|
|
C next = leastValueAbove(domain);
|
||
|
|
return (next != null) ? belowValue(next) : Cut.<C>aboveAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public int hashCode() {
|
||
|
|
return ~endpoint.hashCode();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String toString() {
|
||
|
|
return "/" + endpoint + "\\";
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final long serialVersionUID = 0;
|
||
|
|
}
|
||
|
|
}
|