Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 org.apache.druid.java.util.common; import org.apache.druid.java.util.common.guava.Comparators; import org.joda.time.DateTime; import org.joda.time.Interval; import java.util.ArrayList; import java.util.Iterator; import java.util.SortedSet; import java.util.TreeSet; /** */ public class JodaUtils { // limit intervals such that duration millis fits in a long public static final long MAX_INSTANT = Long.MAX_VALUE / 2; public static final long MIN_INSTANT = Long.MIN_VALUE / 2; public static ArrayList<Interval> condenseIntervals(Iterable<Interval> intervals) { ArrayList<Interval> retVal = new ArrayList<>(); final SortedSet<Interval> sortedIntervals; if (intervals instanceof SortedSet) { sortedIntervals = (SortedSet<Interval>) intervals; } else { sortedIntervals = new TreeSet<>(Comparators.intervalsByStartThenEnd()); for (Interval interval : intervals) { sortedIntervals.add(interval); } } if (sortedIntervals.isEmpty()) { return new ArrayList<>(); } Iterator<Interval> intervalsIter = sortedIntervals.iterator(); Interval currInterval = intervalsIter.next(); while (intervalsIter.hasNext()) { Interval next = intervalsIter.next(); if (currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else if (currInterval.overlaps(next)) { DateTime nextEnd = next.getEnd(); DateTime currEnd = currInterval.getEnd(); currInterval = new Interval(currInterval.getStart(), nextEnd.isAfter(currEnd) ? nextEnd : currEnd); } else { retVal.add(currInterval); currInterval = next; } } retVal.add(currInterval); return retVal; } public static Interval umbrellaInterval(Iterable<Interval> intervals) { ArrayList<DateTime> startDates = new ArrayList<>(); ArrayList<DateTime> endDates = new ArrayList<>(); for (Interval interval : intervals) { startDates.add(interval.getStart()); endDates.add(interval.getEnd()); } DateTime minStart = minDateTime(startDates.toArray(new DateTime[0])); DateTime maxEnd = maxDateTime(endDates.toArray(new DateTime[0])); if (minStart == null || maxEnd == null) { throw new IllegalArgumentException("Empty list of intervals"); } return new Interval(minStart, maxEnd); } public static DateTime minDateTime(DateTime... times) { if (times == null) { return null; } switch (times.length) { case 0: return null; case 1: return times[0]; default: DateTime min = times[0]; for (int i = 1; i < times.length; ++i) { min = min.isBefore(times[i]) ? min : times[i]; } return min; } } public static DateTime maxDateTime(DateTime... times) { if (times == null) { return null; } switch (times.length) { case 0: return null; case 1: return times[0]; default: DateTime max = times[0]; for (int i = 1; i < times.length; ++i) { max = max.isAfter(times[i]) ? max : times[i]; } return max; } } }