org.sleuthkit.autopsy.timeline.utils.IntervalUtils.java Source code

Introduction

Here is the source code for org.sleuthkit.autopsy.timeline.utils.IntervalUtils.java

Source

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2013 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * 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 org.sleuthkit.autopsy.timeline.utils;

import java.util.Collection;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.Interval;
import org.joda.time.ReadablePeriod;
import org.sleuthkit.autopsy.timeline.zooming.TimeUnits;

/**
 *
 */
public class IntervalUtils {

    static public Interval getSpanningInterval(Collection<DateTime> times) {
        Interval trange = null;
        for (DateTime t : times) {
            if (trange == null) {
                trange = new Interval(t.getMillis(), t.getMillis() + 1000, DateTimeZone.UTC);
            } else {
                trange = extendInterval(trange, t.getMillis());
            }
        }
        return trange;
    }

    static public Interval span(Interval range, final Interval range2) {
        return new Interval(Math.min(range.getStartMillis(), range2.getStartMillis()),
                Math.max(range.getEndMillis(), range2.getEndMillis()), DateTimeZone.UTC);
    }

    static public Interval extendInterval(Interval range, final Long eventTime) {
        return new Interval(Math.min(range.getStartMillis(), eventTime),
                Math.max(range.getEndMillis(), eventTime + 1), DateTimeZone.UTC);
    }

    public static DateTime middleOf(Interval interval) {
        return new DateTime((interval.getStartMillis() + interval.getEndMillis()) / 2);
    }

    public static Interval getAdjustedInterval(Interval oldInterval, TimeUnits requestedUnit) {
        return getIntervalAround(middleOf(oldInterval), requestedUnit.getPeriod());
    }

    static public Interval getIntervalAround(DateTime aroundInstant, ReadablePeriod period) {
        DateTime start = aroundInstant.minus(period);
        DateTime end = aroundInstant.plus(period);
        Interval range = new Interval(start, end);
        DateTime middleOf = IntervalUtils.middleOf(range);
        long halfRange = range.toDurationMillis() / 4;
        final Interval newInterval = new Interval(middleOf.minus(halfRange), middleOf.plus(halfRange));
        return newInterval;
    }
}