private Duration computeOverlap(Interval x, Interval y) {
if (x.overlaps(y)) {
return x.overlap(y).toDuration();
} else {
return Duration.ZERO;
}
}
private void addBroadcast(Version version, Broadcast newBroadcast) {
if (Strings.isNullOrEmpty(newBroadcast.getSourceId())) {
return;
}
Set<Broadcast> broadcasts = Sets.newHashSet();
Interval newBroadcastInterval = newBroadcast.transmissionInterval().requireValue();
for (Broadcast existingBroadcast : version.getBroadcasts()) {
if (newBroadcast.getSourceId().equals(existingBroadcast.getSourceId())) {
continue;
}
if (existingBroadcast.transmissionInterval().hasValue()) {
Interval currentInterval = existingBroadcast.transmissionInterval().requireValue();
if (existingBroadcast.getBroadcastOn().equals(newBroadcast.getBroadcastOn())
&& currentInterval.overlaps(newBroadcastInterval)) {
continue;
}
}
broadcasts.add(existingBroadcast);
}
broadcasts.add(newBroadcast);
version.setBroadcasts(broadcasts);
}
@Override
public Iterable<Cursor> makeCursors(Filter filter, Interval interval, QueryGranularity gran) {
Interval actualInterval = interval;
if (!actualInterval.overlaps(index.dataInterval)) {
return ImmutableList.of();
}
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 MMappedInvertedIndexSelector(index)));
iterable = new CursorIterable(index, actualInterval, gran, offset);
}
return FunctionalIterable.create(iterable).keep(Functions.<Cursor>identity());
}
public boolean overlaps(final Interval interval) {
Interval regimeInterval = getInterval();
return getBeginDate() != null
&& ((regimeInterval != null && regimeInterval.overlaps(interval))
|| (regimeInterval == null
&& !getBeginDate().isAfter(interval.getEnd().toLocalDate())));
}
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()));
}
}
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;
}
static void checkDistinctness(List<Interval> intervals) {
for (int i = 0; i < intervals.size(); i++) {
Interval x = intervals.get(i);
for (int j = i + 1; j < intervals.size(); j++) {
Interval y = intervals.get(j);
if (x.overlaps(y)) {
throw new IllegalArgumentException(x.toString() + " overlaps " + y.toString());
}
}
}
}
/**
* @param timeline
* @param key
* @param entry
* @return boolean flag indicating whether or not we inserted or discarded something
*/
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;
}
while (entryInterval != null && 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; // discard this entry
}
}
} 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;
}
