Example usage for org.joda.time Interval overlaps

List of usage examples for org.joda.time Interval overlaps

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. Interval
  6. overlaps

Introduction

In this page you can find the example usage for org.joda.time Interval overlaps.

Prototype

public boolean overlaps(ReadableInterval interval)

Source Link

Document

Does this time interval overlap the specified time interval.

Usage

From source file:com.metamx.druid.index.v1.MMappedIndexStorageAdapter.java

License:Open Source License

@Override
public Iterable<Cursor> makeCursors(Filter filter, Interval interval, QueryGranularity gran) {
    Interval actualInterval = interval;
    if (!actualInterval.overlaps(index.dataInterval)) {
        return ImmutableList.of();
    }/*from   w ww .j a v  a  2 s  .  co m*/

    if (actualInterval.getStart().isBefore(index.dataInterval.getStart())) {
        actualInterval = actualInterval.withStart(index.dataInterval.getStart());
    }
    if (actualInterval.getEnd().isAfter(index.dataInterval.getEnd())) {
        actualInterval = actualInterval.withEnd(index.dataInterval.getEnd());
    }

    final Iterable<Cursor> iterable;
    if (filter == null) {
        iterable = new NoFilterCursorIterable(index, actualInterval, gran);
    } else {
        Offset offset = new ConciseOffset(filter.goConcise(new MMappedBitmapIndexSelector(index)));

        iterable = new CursorIterable(index, actualInterval, gran, offset);
    }

    return FunctionalIterable.create(iterable).keep(Functions.<Cursor>identity());
}

From source file:com.metamx.druid.index.v1.QueryableIndexStorageAdapter.java

License:Open Source License

@Override
public Iterable<Cursor> makeCursors(Filter filter, Interval interval, QueryGranularity gran) {
    Interval actualInterval = interval;
    final Interval dataInterval = getInterval();
    if (!actualInterval.overlaps(dataInterval)) {
        return ImmutableList.of();
    }/*from   ww w  . j  a  v  a  2  s.  c om*/

    if (actualInterval.getStart().isBefore(dataInterval.getStart())) {
        actualInterval = actualInterval.withStart(dataInterval.getStart());
    }
    if (actualInterval.getEnd().isAfter(dataInterval.getEnd())) {
        actualInterval = actualInterval.withEnd(dataInterval.getEnd());
    }

    final Iterable<Cursor> iterable;
    if (filter == null) {
        iterable = new NoFilterCursorIterable(index, actualInterval, gran);
    } else {
        Offset offset = new ConciseOffset(filter.goConcise(new MMappedBitmapIndexSelector(index)));

        iterable = new CursorIterable(index, actualInterval, gran, offset);
    }

    return FunctionalIterable.create(iterable).keep(Functions.<Cursor>identity());
}

From source file:com.metamx.druid.indexer.granularity.ArbitraryGranularitySpec.java

License:Open Source License

@JsonCreator
public ArbitraryGranularitySpec(@JsonProperty("intervals") List<Interval> inputIntervals) {
    intervals = Sets.newTreeSet(Comparators.intervalsByStartThenEnd());

    // Insert all intervals
    for (final Interval inputInterval : inputIntervals) {
        intervals.add(inputInterval);/*from   www.j  a  v  a2  s .com*/
    }

    // Ensure intervals are non-overlapping (but they may abut each other)
    final PeekingIterator<Interval> intervalIterator = Iterators.peekingIterator(intervals.iterator());
    while (intervalIterator.hasNext()) {
        final Interval currentInterval = intervalIterator.next();

        if (intervalIterator.hasNext()) {
            final Interval nextInterval = intervalIterator.peek();
            if (currentInterval.overlaps(nextInterval)) {
                throw new IllegalArgumentException(
                        String.format("Overlapping intervals: %s, %s", currentInterval, nextInterval));
            }
        }
    }
}

From source file:com.metamx.druid.indexing.coordinator.TaskLockbox.java

License:Open Source License

/**
 * Return all locks that overlap some search interval.
 *///from  w w w .j  a  v a2s . co m
private List<TaskLockPosse> findLockPossesForInterval(final String dataSource, final Interval interval) {
    giant.lock();

    try {
        final NavigableMap<Interval, TaskLockPosse> dsRunning = running.get(dataSource);
        if (dsRunning == null) {
            // No locks at all
            return Collections.emptyList();
        } else {
            // Tasks are indexed by locked interval, which are sorted by interval start. Intervals are non-overlapping, so:
            final NavigableSet<Interval> dsLockbox = dsRunning.navigableKeySet();
            final Iterable<Interval> searchIntervals = Iterables.concat(
                    // Single interval that starts at or before ours
                    Collections.singletonList(
                            dsLockbox.floor(new Interval(interval.getStart(), new DateTime(Long.MAX_VALUE)))),

                    // All intervals that start somewhere between our start instant (exclusive) and end instant (exclusive)
                    dsLockbox.subSet(new Interval(interval.getStart(), new DateTime(Long.MAX_VALUE)), false,
                            new Interval(interval.getEnd(), interval.getEnd()), false));

            return Lists
                    .newArrayList(FunctionalIterable.create(searchIntervals).filter(new Predicate<Interval>() {
                        @Override
                        public boolean apply(@Nullable Interval searchInterval) {
                            return searchInterval != null && searchInterval.overlaps(interval);
                        }
                    }).transform(new Function<Interval, TaskLockPosse>() {
                        @Override
                        public TaskLockPosse apply(Interval interval) {
                            return dsRunning.get(interval);
                        }
                    }));
        }
    } finally {
        giant.unlock();
    }
}

From source file:com.metamx.druid.master.rules.PeriodLoadRule.java

License:Open Source License

@Override
public boolean appliesTo(DataSegment segment, DateTime referenceTimestamp) {
    final Interval currInterval = new Interval(period, referenceTimestamp);
    return currInterval.overlaps(segment.getInterval());
}

From source file:com.metamx.druid.merger.coordinator.TaskQueue.java

License:Open Source License

/**
 * Return all locks that overlap some search interval.
 *///from www .j  ava  2 s.  c  o m
private List<TaskGroup> findLocks(final String dataSource, final Interval interval) {
    giant.lock();

    try {
        final NavigableMap<Interval, TaskGroup> dsRunning = running.get(dataSource);
        if (dsRunning == null) {
            // No locks at all
            return Collections.emptyList();
        } else {
            // Tasks are indexed by locked interval, which are sorted by interval start. Intervals are non-overlapping, so:
            final NavigableSet<Interval> dsLockbox = dsRunning.navigableKeySet();
            final Iterable<Interval> searchIntervals = Iterables.concat(
                    // Single interval that starts at or before ours
                    Collections.singletonList(
                            dsLockbox.floor(new Interval(interval.getStart(), new DateTime(Long.MAX_VALUE)))),

                    // All intervals that start somewhere between our start instant (exclusive) and end instant (exclusive)
                    dsLockbox.subSet(new Interval(interval.getStart(), new DateTime(Long.MAX_VALUE)), false,
                            new Interval(interval.getEnd(), interval.getEnd()), false));

            return Lists
                    .newArrayList(FunctionalIterable.create(searchIntervals).filter(new Predicate<Interval>() {
                        @Override
                        public boolean apply(@Nullable Interval searchInterval) {
                            return searchInterval != null && searchInterval.overlaps(interval);
                        }
                    }).transform(new Function<Interval, TaskGroup>() {
                        @Override
                        public TaskGroup apply(Interval interval) {
                            return dsRunning.get(interval);
                        }
                    }));
        }
    } finally {
        giant.unlock();
    }
}

From source file:com.metamx.druid.VersionedIntervalTimeline.java

License:Open Source License

private boolean addAtKey(NavigableMap<Interval, TimelineEntry> timeline, Interval key, TimelineEntry entry) {
    boolean retVal = false;
    Interval currKey = key;
    Interval entryInterval = entry.getTrueInterval();

    if (!currKey.overlaps(entryInterval)) {
        return false;
    }// ww  w . j a  v  a2  s.co  m

    while (currKey != null && currKey.overlaps(entryInterval)) {
        Interval nextKey = timeline.higherKey(currKey);

        int versionCompare = versionComparator.compare(entry.getVersion(), timeline.get(currKey).getVersion());

        if (versionCompare < 0) {
            if (currKey.contains(entryInterval)) {
                return true;
            } else if (currKey.getStart().isBefore(entryInterval.getStart())) {
                entryInterval = new Interval(currKey.getEnd(), entryInterval.getEnd());
            } else {
                addIntervalToTimeline(new Interval(entryInterval.getStart(), currKey.getStart()), entry,
                        timeline);

                if (entryInterval.getEnd().isAfter(currKey.getEnd())) {
                    entryInterval = new Interval(currKey.getEnd(), entryInterval.getEnd());
                } else {
                    entryInterval = null;
                }
            }
        } else if (versionCompare > 0) {
            TimelineEntry oldEntry = timeline.remove(currKey);

            if (currKey.contains(entryInterval)) {
                addIntervalToTimeline(new Interval(currKey.getStart(), entryInterval.getStart()), oldEntry,
                        timeline);
                addIntervalToTimeline(new Interval(entryInterval.getEnd(), currKey.getEnd()), oldEntry,
                        timeline);
                addIntervalToTimeline(entryInterval, entry, timeline);

                return true;
            } else if (currKey.getStart().isBefore(entryInterval.getStart())) {
                addIntervalToTimeline(new Interval(currKey.getStart(), entryInterval.getStart()), oldEntry,
                        timeline);
            } else if (entryInterval.getEnd().isBefore(currKey.getEnd())) {
                addIntervalToTimeline(new Interval(entryInterval.getEnd(), currKey.getEnd()), oldEntry,
                        timeline);
            }
        } else {
            if (timeline.get(currKey).equals(entry)) {
                // This occurs when restoring segments
                timeline.remove(currKey);
            } else {
                throw new UnsupportedOperationException(
                        String.format("Cannot add overlapping segments [%s and %s] with the same version [%s]",
                                currKey, entryInterval, entry.getVersion()));
            }
        }

        currKey = nextKey;
        retVal = true;
    }

    addIntervalToTimeline(entryInterval, entry, timeline);

    return retVal;
}

From source file:com.metamx.druid.VersionedIntervalTimeline.java

License:Open Source License

private List<TimelineObjectHolder<VersionType, ObjectType>> lookup(Interval interval, boolean incompleteOk) {
    List<TimelineObjectHolder<VersionType, ObjectType>> retVal = new ArrayList<TimelineObjectHolder<VersionType, ObjectType>>();
    NavigableMap<Interval, TimelineEntry> timeline = (incompleteOk) ? incompletePartitionsTimeline
            : completePartitionsTimeline;

    for (Map.Entry<Interval, TimelineEntry> entry : timeline.entrySet()) {
        Interval timelineInterval = entry.getKey();
        TimelineEntry val = entry.getValue();

        if (timelineInterval.overlaps(interval)) {
            retVal.add(new TimelineObjectHolder<VersionType, ObjectType>(timelineInterval, val.getVersion(),
                    val.getPartitionHolder()));
        }//from w  w w  .j av  a2s.  c om
    }

    if (retVal.isEmpty()) {
        return retVal;
    }

    TimelineObjectHolder<VersionType, ObjectType> firstEntry = retVal.get(0);
    if (interval.overlaps(firstEntry.getInterval())
            && interval.getStart().isAfter(firstEntry.getInterval().getStart())) {
        retVal.set(0,
                new TimelineObjectHolder<VersionType, ObjectType>(
                        new Interval(interval.getStart(), firstEntry.getInterval().getEnd()),
                        firstEntry.getVersion(), firstEntry.getObject()));
    }

    TimelineObjectHolder<VersionType, ObjectType> lastEntry = retVal.get(retVal.size() - 1);
    if (interval.overlaps(lastEntry.getInterval())
            && interval.getEnd().isBefore(lastEntry.getInterval().getEnd())) {
        retVal.set(retVal.size() - 1,
                new TimelineObjectHolder<VersionType, ObjectType>(
                        new Interval(lastEntry.getInterval().getStart(), interval.getEnd()),
                        lastEntry.getVersion(), lastEntry.getObject()));
    }

    return retVal;
}

From source file:com.peertopark.java.dates.Intervals.java

License:Apache License

public static boolean overlaps(Interval interval, Interval toCompare) {
    if (Objects.allNotNull(toCompare, interval)) {
        return toCompare.overlaps(interval);
    } else {// w  ww .  ja v a  2  s .co m
        return false;
    }
}

From source file:com.sheepdog.mashmesh.models.VolunteerProfile.java

License:Apache License

public boolean isTimeslotOccupied(DateTime startDateTime, DateTime endDateTime) {
    Interval requestedInterval = new Interval(startDateTime, endDateTime);

    for (AppointmentPeriod appointmentTime : appointmentTimes) {
        Interval appointmentInterval = new Interval(appointmentTime.startTimeMillis,
                appointmentTime.endTimeMillis);

        if (appointmentInterval.overlaps(requestedInterval)) {
            return true;
        }//ww w  .  j  a  va2  s  .  c  o  m
    }

    return false;
}