mirror of
https://github.com/Eaglercraft-Archive/Eaglercraftx-1.8.8-src.git
synced 2025-06-28 02:48:14 -05:00
Update #0 - First Release
This commit is contained in:
LAX1DUDE
459
sources/main/java/com/google/common/collect/Cut.java
Normal file
459
sources/main/java/com/google/common/collect/Cut.java
Normal file
@ -0,0 +1,459 @@
|
||||
/*
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user