range - 将 Guava 范围转换为不同的类型

Question

如何转换给定的 Guava Range一种类型到另一种类型的范围。

我期待一个类似于 Predicates.compose 的组合方法。以 Integer 和 Long 为例:

Range<Integer> intRange = Range.compose(Range.atLeast(10l),integerFromLongFunction);

我写了 compose 方法:

    public static <F extends Comparable<F>, T extends Comparable<T>> Range<T> compose(Range<F> range,
        Function<F, T> function) {
    Range<T> result;
    if (range.hasUpperBound() && range.hasLowerBound()) {
        T upperEndpoint = function.apply(range.upperEndpoint());
        T lowerEndpoint = function.apply(range.lowerEndpoint());
        result = Range.range(lowerEndpoint, range.lowerBoundType(), upperEndpoint, range.upperBoundType());
    } else if (range.hasUpperBound()) {
        result = Range.upTo(function.apply(range.upperEndpoint()), range.upperBoundType());
    } else if (range.hasLowerBound()) {
        result = Range.downTo(function.apply(range.lowerEndpoint()), range.lowerBoundType());
    } else {
        result = Range.all();
    }
    return result;
}

单元测试:

@Test
public void testLongRangeToInteger() {
    Integer inRange = 6;
    Integer outOfRange = 3;
    Range<Long> longRange = Range.atLeast(5l);
    assertTrue(longRange.apply(inRange.longValue()));
    assertFalse(longRange.apply(outOfRange.longValue()));

    Function<Long, Integer> function = integerFromLongFunction();
    Range<Integer> intRange = RangeExtended.compose(longRange, function);
    assertTrue(intRange.apply(inRange));
    assertFalse(intRange.apply(outOfRange));
}

public static Function<Long, Integer> integerFromLongFunction() {
    return new Function<Long, Integer>() {

        @Override
        public Integer apply(Long input) {
            return (input == null) ? null : input.intValue();
        }
    };
}

我目前的愿望实际上是将 Joda Duration 转换为它对应的毫秒，但为了简单起见，我在 Long/Integer 中编写了示例。

Guava 似乎有这个，但我找不到任何地方。我使用的是 v14，但查看最新的 v17 javadoc 没有发现任何内容。

Answer 1

在 guava 31.1 中似乎仍然不是一个方便的转换方法。

一个简单的实现是这样的:

public static <T extends Comparable<T>, U extends Comparable<U>>
@Nonnull Range<U> toRangeType( 
    @Nonnull Range<T> t, 
    @Nonnull Function<T,U> map ) 
{
    Range<U> u;
    
    boolean hasLowerBound = t.hasLowerBound();
    boolean hasUpperBound = t.hasUpperBound();
    
    if ( hasLowerBound) {
        if ( hasUpperBound ) {
            u = Range.range(  
                    map.apply( t.lowerEndpoint()), t.lowerBoundType(), 
                    map.apply( t.upperEndpoint()), t.upperBoundType());
        }
        else {
            u = Range.downTo( map.apply( t.lowerEndpoint()), t.lowerBoundType());
        }
    }
    else {
        if ( hasUpperBound ) {
            u = Range.upTo( map.apply( t.upperEndpoint()), t.upperBoundType());
        }
        else {
            u = Range.all();
        }
    }
    
    return u;
}