com.google.common.collect.RegularContiguousSet Maven / Gradle / Ivy
Go to download
Guava is a suite of core and expanded libraries that include
utility classes, Google's collections, I/O classes, and
much more.
This project includes GWT-friendly sources.
/*
* Copyright (C) 2011 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.checkArgument;
import static com.google.common.base.Preconditions.checkElementIndex;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.BoundType.CLOSED;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Collection;
import javax.annotation.CheckForNull;
/**
* An implementation of {@link ContiguousSet} that contains one or more elements.
*
* @author Gregory Kick
*/
@GwtCompatible(emulated = true)
@SuppressWarnings("unchecked") // allow ungenerified Comparable types
@ElementTypesAreNonnullByDefault
final class RegularContiguousSet extends ContiguousSet {
private final Range range;
RegularContiguousSet(Range range, DiscreteDomain domain) {
super(domain);
this.range = range;
}
private ContiguousSet intersectionInCurrentDomain(Range other) {
return range.isConnected(other)
? ContiguousSet.create(range.intersection(other), domain)
: new EmptyContiguousSet(domain);
}
@Override
ContiguousSet headSetImpl(C toElement, boolean inclusive) {
return intersectionInCurrentDomain(Range.upTo(toElement, BoundType.forBoolean(inclusive)));
}
@Override
ContiguousSet subSetImpl(
C fromElement, boolean fromInclusive, C toElement, boolean toInclusive) {
if (fromElement.compareTo(toElement) == 0 && !fromInclusive && !toInclusive) {
// Range would reject our attempt to create (x, x).
return new EmptyContiguousSet<>(domain);
}
return intersectionInCurrentDomain(
Range.range(
fromElement, BoundType.forBoolean(fromInclusive),
toElement, BoundType.forBoolean(toInclusive)));
}
@Override
ContiguousSet tailSetImpl(C fromElement, boolean inclusive) {
return intersectionInCurrentDomain(Range.downTo(fromElement, BoundType.forBoolean(inclusive)));
}
@GwtIncompatible // not used by GWT emulation
@Override
int indexOf(@CheckForNull Object target) {
// requireNonNull is safe because of the contains check.
return contains(target) ? (int) domain.distance(first(), (C) requireNonNull(target)) : -1;
}
@Override
public UnmodifiableIterator iterator() {
return new AbstractSequentialIterator(first()) {
final C last = last();
@Override
@CheckForNull
protected C computeNext(C previous) {
return equalsOrThrow(previous, last) ? null : domain.next(previous);
}
};
}
@GwtIncompatible // NavigableSet
@Override
public UnmodifiableIterator descendingIterator() {
return new AbstractSequentialIterator(last()) {
final C first = first();
@Override
@CheckForNull
protected C computeNext(C previous) {
return equalsOrThrow(previous, first) ? null : domain.previous(previous);
}
};
}
private static boolean equalsOrThrow(Comparable left, @CheckForNull Comparable right) {
return right != null && Range.compareOrThrow(left, right) == 0;
}
@Override
boolean isPartialView() {
return false;
}
@Override
public C first() {
// requireNonNull is safe because we checked the range is not empty in ContiguousSet.create.
return requireNonNull(range.lowerBound.leastValueAbove(domain));
}
@Override
public C last() {
// requireNonNull is safe because we checked the range is not empty in ContiguousSet.create.
return requireNonNull(range.upperBound.greatestValueBelow(domain));
}
@Override
ImmutableList createAsList() {
if (domain.supportsFastOffset) {
return new ImmutableAsList() {
@Override
ImmutableSortedSet delegateCollection() {
return RegularContiguousSet.this;
}
@Override
public C get(int i) {
checkElementIndex(i, size());
return domain.offset(first(), i);
}
};
} else {
return super.createAsList();
}
}
@Override
public int size() {
long distance = domain.distance(first(), last());
return (distance >= Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) distance + 1;
}
@Override
public boolean contains(@CheckForNull Object object) {
if (object == null) {
return false;
}
try {
return range.contains((C) object);
} catch (ClassCastException e) {
return false;
}
}
@Override
public boolean containsAll(Collection targets) {
return Collections2.containsAllImpl(this, targets);
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public ContiguousSet intersection(ContiguousSet other) {
checkNotNull(other);
checkArgument(this.domain.equals(other.domain));
if (other.isEmpty()) {
return other;
} else {
C lowerEndpoint = Ordering.natural().max(this.first(), other.first());
C upperEndpoint = Ordering.natural().min(this.last(), other.last());
return (lowerEndpoint.compareTo(upperEndpoint) <= 0)
? ContiguousSet.create(Range.closed(lowerEndpoint, upperEndpoint), domain)
: new EmptyContiguousSet(domain);
}
}
@Override
public Range range() {
return range(CLOSED, CLOSED);
}
@Override
public Range range(BoundType lowerBoundType, BoundType upperBoundType) {
return Range.create(
range.lowerBound.withLowerBoundType(lowerBoundType, domain),
range.upperBound.withUpperBoundType(upperBoundType, domain));
}
@Override
public boolean equals(@CheckForNull Object object) {
if (object == this) {
return true;
} else if (object instanceof RegularContiguousSet) {
RegularContiguousSet that = (RegularContiguousSet) object;
if (this.domain.equals(that.domain)) {
return this.first().equals(that.first()) && this.last().equals(that.last());
}
}
return super.equals(object);
}
// copied to make sure not to use the GWT-emulated version
@Override
public int hashCode() {
return Sets.hashCodeImpl(this);
}
@GwtIncompatible // serialization
@J2ktIncompatible
private static final class SerializedForm implements Serializable {
final Range range;
final DiscreteDomain domain;
private SerializedForm(Range range, DiscreteDomain domain) {
this.range = range;
this.domain = domain;
}
private Object readResolve() {
return new RegularContiguousSet<>(range, domain);
}
}
@GwtIncompatible // serialization
@J2ktIncompatible
@Override
Object writeReplace() {
return new SerializedForm<>(range, domain);
}
@GwtIncompatible // serialization
@J2ktIncompatible
private void readObject(ObjectInputStream stream) throws InvalidObjectException {
throw new InvalidObjectException("Use SerializedForm");
}
private static final long serialVersionUID = 0;
}