com.fitbur.guava.common.collect.ImmutableRangeMap Maven / Gradle / Ivy
/*
* Copyright (C) 2012 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.fitbur.guava.common.collect;
import static com.fitbur.guava.common.base.Preconditions.checkArgument;
import static com.fitbur.guava.common.base.Preconditions.checkElementIndex;
import static com.fitbur.guava.common.base.Preconditions.checkNotNull;
import com.fitbur.guava.common.annotations.Beta;
import com.fitbur.guava.common.annotations.GwtIncompatible;
import com.fitbur.guava.common.collect.SortedLists.KeyAbsentBehavior;
import com.fitbur.guava.common.collect.SortedLists.KeyPresentBehavior;
import java.io.Serializable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import javax.annotation.Nullable;
/**
* A {@link RangeMap} whose contents will never change, with many other important properties
* detailed at {@link ImmutableCollection}.
*
* @author Louis Wasserman
* @since 14.0
*/
@Beta
@GwtIncompatible("NavigableMap")
public class ImmutableRangeMap, V> implements RangeMap, Serializable {
private static final ImmutableRangeMap, Object> EMPTY =
new ImmutableRangeMap, Object>(
ImmutableList.>>of(), ImmutableList.of());
/**
* Returns an empty immutable range map.
*/
@SuppressWarnings("unchecked")
public static , V> ImmutableRangeMap of() {
return (ImmutableRangeMap) EMPTY;
}
/**
* Returns an immutable range map mapping a single range to a single value.
*/
public static , V> ImmutableRangeMap of(Range range, V value) {
return new ImmutableRangeMap(ImmutableList.of(range), ImmutableList.of(value));
}
@SuppressWarnings("unchecked")
public static , V> ImmutableRangeMap copyOf(
RangeMap rangeMap) {
if (rangeMap instanceof ImmutableRangeMap) {
return (ImmutableRangeMap) rangeMap;
}
Map, ? extends V> map = rangeMap.asMapOfRanges();
ImmutableList.Builder> rangesBuilder = new ImmutableList.Builder>(map.size());
ImmutableList.Builder valuesBuilder = new ImmutableList.Builder(map.size());
for (Entry, ? extends V> entry : map.entrySet()) {
rangesBuilder.add(entry.getKey());
valuesBuilder.add(entry.getValue());
}
return new ImmutableRangeMap(rangesBuilder.build(), valuesBuilder.build());
}
/**
* Returns a new builder for an immutable range map.
*/
public static , V> Builder builder() {
return new Builder();
}
/**
* A builder for immutable range maps. Overlapping ranges are prohibited.
*/
public static final class Builder, V> {
private final RangeSet keyRanges;
private final RangeMap rangeMap;
public Builder() {
this.keyRanges = TreeRangeSet.create();
this.rangeMap = TreeRangeMap.create();
}
/**
* Associates the specified range with the specified value.
*
* @throws IllegalArgumentException if {@code range} overlaps with any other ranges inserted
* into this builder, or if {@code range} is empty
*/
public Builder put(Range range, V value) {
checkNotNull(range);
checkNotNull(value);
checkArgument(!range.isEmpty(), "Range must not be empty, but was %s", range);
if (!keyRanges.complement().encloses(range)) {
// it's an error case; we can afford an expensive lookup
for (Entry, V> entry : rangeMap.asMapOfRanges().entrySet()) {
Range key = entry.getKey();
if (key.isConnected(range) && !key.intersection(range).isEmpty()) {
throw new IllegalArgumentException(
"Overlapping ranges: range " + range + " overlaps with entry " + entry);
}
}
}
keyRanges.add(range);
rangeMap.put(range, value);
return this;
}
/**
* Copies all associations from the specified range map into this builder.
*
* @throws IllegalArgumentException if any of the ranges in {@code rangeMap} overlap with ranges
* already in this builder
*/
public Builder putAll(RangeMap rangeMap) {
for (Entry, ? extends V> entry : rangeMap.asMapOfRanges().entrySet()) {
put(entry.getKey(), entry.getValue());
}
return this;
}
/**
* Returns an {@code ImmutableRangeMap} containing the associations previously added to this
* builder.
*/
public ImmutableRangeMap build() {
Map, V> map = rangeMap.asMapOfRanges();
ImmutableList.Builder> rangesBuilder =
new ImmutableList.Builder>(map.size());
ImmutableList.Builder valuesBuilder = new ImmutableList.Builder(map.size());
for (Entry, V> entry : map.entrySet()) {
rangesBuilder.add(entry.getKey());
valuesBuilder.add(entry.getValue());
}
return new ImmutableRangeMap(rangesBuilder.build(), valuesBuilder.build());
}
}
private final transient ImmutableList> ranges;
private final transient ImmutableList values;
ImmutableRangeMap(ImmutableList> ranges, ImmutableList values) {
this.ranges = ranges;
this.values = values;
}
@Override
@Nullable
public V get(K key) {
int index =
SortedLists.binarySearch(
ranges,
Range.lowerBoundFn(),
Cut.belowValue(key),
KeyPresentBehavior.ANY_PRESENT,
KeyAbsentBehavior.NEXT_LOWER);
if (index == -1) {
return null;
} else {
Range range = ranges.get(index);
return range.contains(key) ? values.get(index) : null;
}
}
@Override
@Nullable
public Map.Entry, V> getEntry(K key) {
int index =
SortedLists.binarySearch(
ranges,
Range.lowerBoundFn(),
Cut.belowValue(key),
KeyPresentBehavior.ANY_PRESENT,
KeyAbsentBehavior.NEXT_LOWER);
if (index == -1) {
return null;
} else {
Range range = ranges.get(index);
return range.contains(key) ? Maps.immutableEntry(range, values.get(index)) : null;
}
}
@Override
public Range span() {
if (ranges.isEmpty()) {
throw new NoSuchElementException();
}
Range firstRange = ranges.get(0);
Range lastRange = ranges.get(ranges.size() - 1);
return Range.create(firstRange.lowerBound, lastRange.upperBound);
}
@Override
public void put(Range range, V value) {
throw new UnsupportedOperationException();
}
@Override
public void putAll(RangeMap rangeMap) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
throw new UnsupportedOperationException();
}
@Override
public void remove(Range range) {
throw new UnsupportedOperationException();
}
@Override
public ImmutableMap, V> asMapOfRanges() {
if (ranges.isEmpty()) {
return ImmutableMap.of();
}
RegularImmutableSortedSet> rangeSet =
new RegularImmutableSortedSet>(ranges, Range.RANGE_LEX_ORDERING);
return new ImmutableSortedMap, V>(rangeSet, values);
}
@Override
public ImmutableMap, V> asDescendingMapOfRanges() {
if (ranges.isEmpty()) {
return ImmutableMap.of();
}
RegularImmutableSortedSet> rangeSet =
new RegularImmutableSortedSet>(
ranges.reverse(), Range.RANGE_LEX_ORDERING.reverse());
return new ImmutableSortedMap, V>(rangeSet, values.reverse());
}
@Override
public ImmutableRangeMap subRangeMap(final Range range) {
if (checkNotNull(range).isEmpty()) {
return ImmutableRangeMap.of();
} else if (ranges.isEmpty() || range.encloses(span())) {
return this;
}
int lowerIndex =
SortedLists.binarySearch(
ranges,
Range.upperBoundFn(),
range.lowerBound,
KeyPresentBehavior.FIRST_AFTER,
KeyAbsentBehavior.NEXT_HIGHER);
int upperIndex =
SortedLists.binarySearch(
ranges,
Range.lowerBoundFn(),
range.upperBound,
KeyPresentBehavior.ANY_PRESENT,
KeyAbsentBehavior.NEXT_HIGHER);
if (lowerIndex >= upperIndex) {
return ImmutableRangeMap.of();
}
final int off = lowerIndex;
final int len = upperIndex - lowerIndex;
ImmutableList> subRanges =
new ImmutableList>() {
@Override
public int size() {
return len;
}
@Override
public Range get(int index) {
checkElementIndex(index, len);
if (index == 0 || index == len - 1) {
return ranges.get(index + off).intersection(range);
} else {
return ranges.get(index + off);
}
}
@Override
boolean isPartialView() {
return true;
}
};
final ImmutableRangeMap outer = this;
return new ImmutableRangeMap(subRanges, values.subList(lowerIndex, upperIndex)) {
@Override
public ImmutableRangeMap subRangeMap(Range subRange) {
if (range.isConnected(subRange)) {
return outer.subRangeMap(subRange.intersection(range));
} else {
return ImmutableRangeMap.of();
}
}
};
}
@Override
public int hashCode() {
return asMapOfRanges().hashCode();
}
@Override
public boolean equals(@Nullable Object o) {
if (o instanceof RangeMap) {
RangeMap rangeMap = (RangeMap) o;
return asMapOfRanges().equals(rangeMap.asMapOfRanges());
}
return false;
}
@Override
public String toString() {
return asMapOfRanges().toString();
}
/**
* This class is used to serialize ImmutableRangeMap instances.
* Serializes the {@link #asMapOfRanges()} form.
*/
private static class SerializedForm, V> implements Serializable {
private final ImmutableMap, V> mapOfRanges;
SerializedForm(ImmutableMap, V> mapOfRanges) {
this.mapOfRanges = mapOfRanges;
}
Object readResolve() {
if (mapOfRanges.isEmpty()) {
return of();
} else {
return createRangeMap();
}
}
Object createRangeMap() {
Builder builder = new Builder();
for (Entry, V> entry : mapOfRanges.entrySet()) {
builder.put(entry.getKey(), entry.getValue());
}
return builder.build();
}
private static final long serialVersionUID = 0;
}
Object writeReplace() {
return new SerializedForm(asMapOfRanges());
}
private static final long serialVersionUID = 0;
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy