001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018package org.apache.commons.lang3.time; 019 020import java.time.Duration; 021import java.time.temporal.ChronoUnit; 022import java.util.Objects; 023import java.util.concurrent.TimeUnit; 024 025import org.apache.commons.lang3.ObjectUtils; 026import org.apache.commons.lang3.Range; 027import org.apache.commons.lang3.function.FailableBiConsumer; 028import org.apache.commons.lang3.math.NumberUtils; 029 030/** 031 * Utilities for {@link Duration}. 032 * 033 * @since 3.12.0 034 */ 035public class DurationUtils { 036 037 /** 038 * An Integer Range that accepts Longs. 039 */ 040 static final Range<Long> LONG_TO_INT_RANGE = Range.between(NumberUtils.LONG_INT_MIN_VALUE, 041 NumberUtils.LONG_INT_MAX_VALUE); 042 043 /** 044 * Accepts the function with the duration as a long milliseconds and int nanoseconds. 045 * 046 * @param <T> The function exception. 047 * @param consumer Accepting function. 048 * @param duration The duration to pick apart. 049 * @throws T See the function signature. 050 */ 051 public static <T extends Throwable> void accept(final FailableBiConsumer<Long, Integer, T> consumer, final Duration duration) 052 throws T { 053 if (consumer != null && duration != null) { 054 consumer.accept(duration.toMillis(), getNanosOfMiili(duration)); 055 } 056 } 057 058 /** 059 * Gets the nanosecond part of a Duration converted to milliseconds. 060 * <p> 061 * Handy when calling an API that takes a long of milliseconds and an int of nanoseconds. For example, 062 * {@link Object#wait(long, int)} and {@link Thread#sleep(long, int)}. 063 * </p> 064 * <p> 065 * Note that is this different from {@link Duration#getNano()} because a duration are seconds and nanoseconds. 066 * </p> 067 * 068 * @param duration The duration to query. 069 * @return nanoseconds between 0 and 999,999. 070 */ 071 public static int getNanosOfMiili(final Duration duration) { 072 return duration.getNano() % 1_000_000; 073 } 074 075 /** 076 * Tests whether the given Duration is positive (>0). 077 * 078 * @param duration the value to test 079 * @return whether the given Duration is positive (>0). 080 */ 081 public static boolean isPositive(final Duration duration) { 082 return !duration.isNegative() && !duration.isZero(); 083 } 084 085 /** 086 * Converts a {@link TimeUnit} to a {@link ChronoUnit}. 087 * 088 * @param timeUnit A non-null TimeUnit. 089 * @return The corresponding ChronoUnit. 090 */ 091 static ChronoUnit toChronoUnit(final TimeUnit timeUnit) { 092 // TODO when using Java >= 9: Use TimeUnit.toChronoUnit(). 093 switch (Objects.requireNonNull(timeUnit)) { 094 case NANOSECONDS: 095 return ChronoUnit.NANOS; 096 case MICROSECONDS: 097 return ChronoUnit.MICROS; 098 case MILLISECONDS: 099 return ChronoUnit.MILLIS; 100 case SECONDS: 101 return ChronoUnit.SECONDS; 102 case MINUTES: 103 return ChronoUnit.MINUTES; 104 case HOURS: 105 return ChronoUnit.HOURS; 106 case DAYS: 107 return ChronoUnit.DAYS; 108 default: 109 throw new IllegalArgumentException(timeUnit.toString()); 110 } 111 } 112 113 /** 114 * Converts an amount and TimeUnit into a Duration. 115 * 116 * @param amount the amount of the duration, measured in terms of the unit, positive or negative 117 * @param timeUnit the unit that the duration is measured in, must have an exact duration, not null 118 * @return a Duration. 119 */ 120 public static Duration toDuration(final long amount, final TimeUnit timeUnit) { 121 return Duration.of(amount, toChronoUnit(timeUnit)); 122 } 123 124 /** 125 * Converts a Duration to milliseconds bound to an int (instead of a long). 126 * <p> 127 * Handy for low-level APIs that take millisecond timeouts in ints rather than longs. 128 * </p> 129 * <ul> 130 * <li>If the duration milliseconds are greater than {@link Integer#MAX_VALUE}, then return 131 * {@link Integer#MAX_VALUE}.</li> 132 * <li>If the duration milliseconds are lesser than {@link Integer#MIN_VALUE}, then return 133 * {@link Integer#MIN_VALUE}.</li> 134 * </ul> 135 * 136 * @param duration The duration to convert, not null. 137 * @return int milliseconds. 138 */ 139 public static int toMillisInt(final Duration duration) { 140 Objects.requireNonNull(duration, "duration"); 141 // intValue() does not do a narrowing conversion here 142 return LONG_TO_INT_RANGE.fit(Long.valueOf(duration.toMillis())).intValue(); 143 } 144 145 /** 146 * Returns the given non-null value or {@link Duration#ZERO} if null. 147 * 148 * @param duration The duration to test. 149 * @return The given duration or {@link Duration#ZERO}. 150 */ 151 public static Duration zeroIfNull(final Duration duration) { 152 return ObjectUtils.defaultIfNull(duration, Duration.ZERO); 153 } 154 155}