List of usage examples for org.joda.time Interval overlaps
public boolean overlaps(ReadableInterval interval)
From source file:com.almende.eve.agent.MeetingAgent.java
License:Apache License
/** * Calculate whether given interval is feasible (i.e. does not overlap with * any of the infeasible intervals, and is not in the past) * // ww w . j av a2s . c om * @param infeasibleIntervals * list with intervals ordered by start * @param timeMin * @param timeMax * @return feasible */ private boolean calculateFeasible(final List<Interval> infeasibleIntervals, final Interval test) { if (test.getStart().isBeforeNow()) { // interval starts in the past return false; } for (final Interval interval : infeasibleIntervals) { if (test.overlaps(interval)) { return false; } if (interval.getStart().isAfter(test.getEnd())) { // as the list is ordered, we can exit as soon as we have an // interval which starts after the wanted interval. break; } } return true; }
From source file:com.baulsupp.kolja.ansi.reports.basic.ActiveRequests.java
License:Open Source License
public boolean isActive(RequestLine line) { if (!initialised) { interval = calculateInterval(line); initialised = true;/* www. jav a2 s.c o m*/ } if (interval == null) { return true; } Interval requestInterval = (Interval) line.getValue(LogConstants.INTERVAL); if (requestInterval == null) { return false; } return requestInterval.overlaps(interval) || requestInterval.abuts(interval); }
From source file:com.marand.thinkmed.medications.business.impl.DefaultMedicationsBo.java
License:Open Source License
boolean areTherapiesSimilar( final Pair<MedicationOrderComposition, MedicationInstructionInstruction> instructionPair, final Pair<MedicationOrderComposition, MedicationInstructionInstruction> compareInstructionPair, final Map<Long, MedicationDataForTherapyDto> medicationsMap, final boolean canOverlap) { final OrderActivity orderActivity = MedicationsEhrUtils .getRepresentingOrderActivity(instructionPair.getSecond()); final OrderActivity compareOrderActivity = MedicationsEhrUtils .getRepresentingOrderActivity(compareInstructionPair.getSecond()); final boolean simpleTherapy = MedicationsEhrUtils.isSimpleTherapy(orderActivity); final Interval therapyInterval = MedicationsEhrUtils .getInstructionInterval(orderActivity.getMedicationTiming()); final Interval therapyOrderInterval = MedicationsEhrUtils .getInstructionInterval(compareOrderActivity.getMedicationTiming()); if (canOverlap || !therapyInterval.overlaps(therapyOrderInterval)) { final boolean compareTherapyIsSimple = MedicationsEhrUtils.isSimpleTherapy(compareOrderActivity); if (simpleTherapy && compareTherapyIsSimple) { final boolean similarSimpleTherapy = isSimilarSimpleTherapy(orderActivity, compareOrderActivity, medicationsMap);//from w w w. j a v a2s . c o m if (similarSimpleTherapy) { return true; } } if (!simpleTherapy && !compareTherapyIsSimple) { final boolean similarComplexTherapy = isSimilarComplexTherapy(orderActivity, compareOrderActivity, medicationsMap); if (similarComplexTherapy) { return true; } } } return false; }
From source file:com.marand.thinkmed.medications.business.impl.DefaultMedicationsBo.java
License:Open Source License
@Override public List<TherapySurgeryReportElementDto> getTherapySurgeryReportElements(@Nonnull final String patientId, final Double patientHeight, @Nonnull final DateTime searchStart, @Nonnull final RoundsIntervalDto roundsIntervalDto, @Nonnull final Locale locale, @Nonnull final DateTime when) { Preconditions.checkNotNull(patientId, "patientId"); Preconditions.checkNotNull(searchStart, "searchStart"); Preconditions.checkNotNull(roundsIntervalDto, "roundsIntervalDto"); Preconditions.checkNotNull(locale, "locale"); Preconditions.checkNotNull(when, "when"); final DateTime roundsStart = new DateTime(searchStart.getYear(), searchStart.getMonthOfYear(), searchStart.getDayOfMonth(), roundsIntervalDto.getStartHour(), roundsIntervalDto.getStartMinute()); final List<Pair<MedicationOrderComposition, MedicationInstructionInstruction>> instructionsList = medicationsOpenEhrDao .findMedicationInstructions(patientId, Intervals.infiniteFrom(roundsStart), null); final Double referenceWeight = medicationsOpenEhrDao.getPatientLastReferenceWeight(patientId, Intervals.infiniteTo(searchStart)); final List<TherapySurgeryReportElementDto> elements = new ArrayList<>(); final Map<Long, MedicationDataForTherapyDto> medicationsMap = getMedicationDataForTherapies( instructionsList, null);// w ww . j a v a2s. c om for (final Pair<MedicationOrderComposition, MedicationInstructionInstruction> instructionPair : instructionsList) { final MedicationOrderComposition composition = instructionPair.getFirst(); final MedicationInstructionInstruction instruction = instructionPair.getSecond(); final MedicationTimingCluster medicationTiming = instruction.getOrder().get(0).getMedicationTiming(); final Interval instructionInterval = MedicationsEhrUtils.getInstructionInterval(medicationTiming); final boolean onlyOnce = isOnlyOnceThenEx(medicationTiming); if (instructionInterval.overlaps(Intervals.infiniteFrom(searchStart)) || onlyOnce && instructionInterval.getStart().isAfter(searchStart.minusHours(1))) { final List<MedicationActionAction> actions = MedicationsEhrUtils.getInstructionActions(composition, instruction); if (!isTherapyCanceledAbortedOrSuspended(actions)) { final TherapyDto therapy = getTherapyFromMedicationInstruction(composition, instruction, referenceWeight, patientHeight, when); therapyDisplayProvider.fillDisplayValues(therapy, false, true, false, locale, true); final boolean containsAntibiotics = getMedicationIds( MedicationsEhrUtils.getRepresentingOrderActivity(instruction)).stream().anyMatch( id -> medicationsMap.containsKey(id) && medicationsMap.get(id).isAntibiotic()); if (containsAntibiotics) { final int consecutiveDays = getTherapyConsecutiveDay( getOriginalTherapyStart(patientId, composition), when, when, therapy.getPastDaysOfTherapy()); elements.add(new TherapySurgeryReportElementDto(therapy.getFormattedTherapyDisplay(), consecutiveDays)); } else { elements.add(new TherapySurgeryReportElementDto(therapy.getFormattedTherapyDisplay())); } } } } return elements; }
From source file:com.marand.thinkmed.medications.business.impl.DefaultMedicationsBo.java
License:Open Source License
DocumentationTherapiesDto getTherapiesForDocumentation(final String patientId, final String centralCaseId, final Interval centralCaseEffective, final List<Pair<MedicationOrderComposition, MedicationInstructionInstruction>> instructionPairs, final Map<Long, MedicationDataForTherapyDto> medicationsDataMap, final boolean isOutpatient, final DateTime when, final Locale locale) { final List<TherapyDocumentationData> therapies = new ArrayList<>(); final List<TherapyDocumentationData> dischargeTherapies = new ArrayList<>(); final List<TherapyDocumentationData> admissionTherapies = new ArrayList<>(); final List<TherapyDto> taggedTherapiesForPrescription = new ArrayList<>(); if (!isOutpatient) { //use taggedTherapiesForPrescription to display medication on discharge list for EMRAM final List<MedicationOnDischargeComposition> dischargeCompositions = medicationsOpenEhrDao .findMedicationOnDischargeCompositions(patientId, centralCaseEffective); for (final MedicationOnDischargeComposition dischargeComposition : dischargeCompositions) { final TherapyDto convertedTherapy = convertInstructionToTherapyDtoWithDisplayValues( dischargeComposition, dischargeComposition.getMedicationDetail().getMedicationInstruction().get(0), null, null, when, true, locale); taggedTherapiesForPrescription.add(convertedTherapy); }//w ww . j ava 2 s .co m } final Set<TherapyDocumentationData> alreadyHandled = new HashSet<>(); final boolean isOutpatientOrLastsOneDay = isOutpatient || Intervals.durationInDays(centralCaseEffective) <= 1; for (final Pair<MedicationOrderComposition, MedicationInstructionInstruction> instructionPair : instructionPairs) { final DateTime therapyStart = DataValueUtils.getDateTime( instructionPair.getSecond().getOrder().get(0).getMedicationTiming().getStartDate()); final DateTime therapyEnd = DataValueUtils .getDateTime(instructionPair.getSecond().getOrder().get(0).getMedicationTiming().getStopDate()); final TherapyDto convertedTherapy = convertInstructionToTherapyDtoWithDisplayValues( instructionPair.getFirst(), instructionPair.getSecond(), null, null, when, true, locale); if (!areAllIngredientsSolutions(convertedTherapy)) { final Interval therapyInterval = new Interval(therapyStart, therapyEnd != null ? therapyEnd : Intervals.INFINITE.getEnd()); final boolean handled = handleSimilarAndLinkedTherapies(admissionTherapies, dischargeTherapies, therapies, alreadyHandled, instructionPair, convertedTherapy, medicationsDataMap, therapyInterval, centralCaseEffective.getEnd(), when); final TherapyDocumentationData therapy = createTherapyData(instructionPair, convertedTherapy, therapyInterval); alreadyHandled.add(therapy); if (!handled) { if (isOutpatientOrLastsOneDay) { if (therapyInterval.overlaps(Intervals.wholeDay(centralCaseEffective.getStart()))) { therapies.add(therapy); } } else { boolean isAdmission = false; if (therapyInterval.overlaps(Intervals.wholeDay(centralCaseEffective.getStart()))) { admissionTherapies.add(therapy); isAdmission = true; } boolean isDischarge = false; if (isDischargeTherapy(therapyInterval, centralCaseEffective.getEnd(), when)) { dischargeTherapies.add(therapy); isDischarge = true; } if (!isAdmission && !isDischarge) { if (therapyInterval.overlaps(centralCaseEffective)) { therapies.add(therapy); } } } } } } return new DocumentationTherapiesDto(getTherapyDisplayValuesForDocumentation(therapies, locale), getTherapyDisplayValuesForDocumentation(dischargeTherapies, locale), getTherapyDisplayValuesForDocumentation(admissionTherapies, locale), getTherapyDisplayValues(taggedTherapiesForPrescription, locale)); }
From source file:com.marand.thinkmed.medications.business.impl.DefaultMedicationsBo.java
License:Open Source License
private boolean isDischargeTherapy(final Interval therapyInterval, final DateTime centralCaseEnd, final DateTime when) { return Intervals.isEndInfinity(therapyInterval.getEnd()) && therapyInterval.overlaps(Intervals.wholeDay(when)) || !Intervals.isEndInfinity(therapyInterval.getEnd()) && therapyInterval.overlaps(Intervals.wholeDay(centralCaseEnd)); }
From source file:com.metamx.common.JodaUtils.java
License:Apache License
public static ArrayList<Interval> condenseIntervals(Iterable<Interval> intervals) { ArrayList<Interval> retVal = Lists.newArrayList(); TreeSet<Interval> sortedIntervals = Sets.newTreeSet(Comparators.intervalsByStartThenEnd()); for (Interval interval : intervals) { sortedIntervals.add(interval);/*ww w . j a v a 2 s. c o m*/ } if (sortedIntervals.isEmpty()) { return Lists.newArrayList(); } Iterator<Interval> intervalsIter = sortedIntervals.iterator(); Interval currInterval = intervalsIter.next(); while (intervalsIter.hasNext()) { Interval next = intervalsIter.next(); if (currInterval.overlaps(next) || currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else { retVal.add(currInterval); currInterval = next; } } retVal.add(currInterval); return retVal; }
From source file:com.metamx.common.JodaUtils.java
License:Apache License
public static boolean overlaps(final Interval i, Iterable<Interval> intervals) { return Iterables.any(intervals, new Predicate<Interval>() { @Override/*from w w w .j a v a 2 s .c om*/ public boolean apply(Interval input) { return input.overlaps(i); } }); }
From source file:com.metamx.druid.index.v1.IncrementalIndexStorageAdapter.java
License:Open Source License
@Override public Iterable<Cursor> makeCursors(final Filter filter, final Interval interval, final QueryGranularity gran) { Interval actualIntervalTmp = interval; Interval dataInterval = getInterval(); if (!actualIntervalTmp.overlaps(dataInterval)) { return ImmutableList.of(); }/*from ww w. j a v a2s. co m*/ if (actualIntervalTmp.getStart().isBefore(dataInterval.getStart())) { actualIntervalTmp = actualIntervalTmp.withStart(dataInterval.getStart()); } if (actualIntervalTmp.getEnd().isAfter(dataInterval.getEnd())) { actualIntervalTmp = actualIntervalTmp.withEnd(dataInterval.getEnd()); } final Interval actualInterval = actualIntervalTmp; return new Iterable<Cursor>() { @Override public Iterator<Cursor> iterator() { return FunctionalIterator.create( gran.iterable(actualInterval.getStartMillis(), actualInterval.getEndMillis()).iterator()) .transform(new Function<Long, Cursor>() { EntryHolder currEntry = new EntryHolder(); private final ValueMatcher filterMatcher; { filterMatcher = makeFilterMatcher(filter, currEntry); } @Override public Cursor apply(@Nullable final Long input) { final long timeStart = Math.max(input, actualInterval.getStartMillis()); return new Cursor() { private Iterator<Map.Entry<IncrementalIndex.TimeAndDims, Aggregator[]>> baseIter; private ConcurrentNavigableMap<IncrementalIndex.TimeAndDims, Aggregator[]> cursorMap; final DateTime time; int numAdvanced = -1; boolean done; { cursorMap = index.getSubMap( new IncrementalIndex.TimeAndDims(timeStart, new String[][] {}), new IncrementalIndex.TimeAndDims(Math .min(actualInterval.getEndMillis(), gran.next(timeStart)), new String[][] {})); time = gran.toDateTime(input); reset(); } @Override public DateTime getTime() { return time; } @Override public void advance() { if (!baseIter.hasNext()) { done = true; return; } while (baseIter.hasNext()) { currEntry.set(baseIter.next()); if (filterMatcher.matches()) { return; } } if (!filterMatcher.matches()) { done = true; } } @Override public boolean isDone() { return done; } @Override public void reset() { baseIter = cursorMap.entrySet().iterator(); if (numAdvanced == -1) { numAdvanced = 0; while (baseIter.hasNext()) { currEntry.set(baseIter.next()); if (filterMatcher.matches()) { return; } numAdvanced++; } } else { Iterators.skip(baseIter, numAdvanced); if (baseIter.hasNext()) { currEntry.set(baseIter.next()); } } done = cursorMap.size() == 0 || !baseIter.hasNext(); } @Override public DimensionSelector makeDimensionSelector(String dimension) { final String dimensionName = dimension.toLowerCase(); final IncrementalIndex.DimDim dimValLookup = index .getDimension(dimensionName); if (dimValLookup == null) { return null; } final int maxId = dimValLookup.size(); final int dimIndex = index.getDimensionIndex(dimensionName); return new DimensionSelector() { @Override public IndexedInts getRow() { final ArrayList<Integer> vals = Lists.newArrayList(); if (dimIndex < currEntry.getKey().getDims().length) { final String[] dimVals = currEntry.getKey().getDims()[dimIndex]; if (dimVals != null) { for (String dimVal : dimVals) { int id = dimValLookup.getId(dimVal); if (id < maxId) { vals.add(id); } } } } return new IndexedInts() { @Override public int size() { return vals.size(); } @Override public int get(int index) { return vals.get(index); } @Override public Iterator<Integer> iterator() { return vals.iterator(); } }; } @Override public int getValueCardinality() { return dimValLookup.size(); } @Override public String lookupName(int id) { return dimValLookup.getValue(id); } @Override public int lookupId(String name) { return dimValLookup.getId(name); } }; } @Override public FloatMetricSelector makeFloatMetricSelector(String metric) { final String metricName = metric.toLowerCase(); final Integer metricIndexInt = index.getMetricIndex(metricName); if (metricIndexInt == null) { return new FloatMetricSelector() { @Override public float get() { return 0.0f; } }; } final int metricIndex = metricIndexInt; return new FloatMetricSelector() { @Override public float get() { return currEntry.getValue()[metricIndex].getFloat(); } }; } @Override public ComplexMetricSelector makeComplexMetricSelector(String metric) { final String metricName = metric.toLowerCase(); final Integer metricIndexInt = index.getMetricIndex(metricName); if (metricIndexInt == null) { return null; } final int metricIndex = metricIndexInt; final ComplexMetricSerde serde = ComplexMetrics .getSerdeForType(index.getMetricType(metricName)); return new ComplexMetricSelector() { @Override public Class classOfObject() { return serde.getObjectStrategy().getClazz(); } @Override public Object get() { return currEntry.getValue()[metricIndex].get(); } }; } }; } }); } }; }
From source file:com.metamx.druid.index.v1.IndexStorageAdapter.java
License:Open Source License
@Override public Iterable<Cursor> makeCursors(final Filter filter, final Interval interval, final QueryGranularity gran) { Interval actualIntervalTmp = interval; if (!actualIntervalTmp.overlaps(index.dataInterval)) { return ImmutableList.of(); }//from www . jav a 2 s . c o m if (actualIntervalTmp.getStart().isBefore(index.dataInterval.getStart())) { actualIntervalTmp = actualIntervalTmp.withStart(index.dataInterval.getStart()); } if (actualIntervalTmp.getEnd().isAfter(index.dataInterval.getEnd())) { actualIntervalTmp = actualIntervalTmp.withEnd(index.dataInterval.getEnd()); } final Interval actualInterval = actualIntervalTmp; final Pair<Integer, Integer> intervalStartAndEnd = computeTimeStartEnd(actualInterval); return new Iterable<Cursor>() { @Override public Iterator<Cursor> iterator() { final Offset baseOffset; if (filter == null) { baseOffset = new ArrayBasedOffset(ids, intervalStartAndEnd.lhs); } else { baseOffset = new StartLimitedOffset( new ConciseOffset(filter.goConcise(new IndexBasedBitmapIndexSelector(index))), intervalStartAndEnd.lhs); } final Map<String, Object> metricHolderCache = Maps.newHashMap(); // This after call is not perfect, if there is an exception during processing, it will never get called, // but it's better than nothing and doing this properly all the time requires a lot more fixerating return MoreIterators.after(FunctionalIterator.create( gran.iterable(actualInterval.getStartMillis(), actualInterval.getEndMillis()).iterator()) .keep(new Function<Long, Cursor>() { @Override public Cursor apply(final Long intervalStart) { final Offset offset = new TimestampCheckingOffset(baseOffset, index.timeOffsets, Math.min(actualInterval.getEndMillis(), gran.next(intervalStart))); return new Cursor() { private final Offset initOffset = offset.clone(); private Offset cursorOffset = offset; private final DateTime timestamp = gran.toDateTime(intervalStart); @Override public DateTime getTime() { return timestamp; } @Override public void advance() { cursorOffset.increment(); } @Override public boolean isDone() { return !cursorOffset.withinBounds(); } @Override public void reset() { cursorOffset = initOffset.clone(); } @Override public DimensionSelector makeDimensionSelector(String dimension) { final String dimensionName = dimension.toLowerCase(); final String[] nameLookup = index.reverseDimLookup.get(dimensionName); if (nameLookup == null) { return null; } return new DimensionSelector() { final Map<String, Integer> dimValLookup = index.dimIdLookup .get(dimensionName); final DimensionColumn dimColumn = index.dimensionValues .get(dimensionName); final int[][] dimensionExpansions = dimColumn.getDimensionExpansions(); final int[] dimensionRowValues = dimColumn.getDimensionRowValues(); @Override public IndexedInts getRow() { return new ArrayBasedIndexedInts( dimensionExpansions[dimensionRowValues[cursorOffset .getOffset()]]); } @Override public int getValueCardinality() { return nameLookup.length; } @Override public String lookupName(int id) { return nameLookup[id]; } @Override public int lookupId(String name) { final Integer retVal = dimValLookup.get(name); return retVal == null ? -1 : retVal; } }; } @Override public FloatMetricSelector makeFloatMetricSelector(String metric) { String metricName = metric.toLowerCase(); IndexedFloats cachedFloats = (IndexedFloats) metricHolderCache.get(metric); if (cachedFloats == null) { MetricHolder holder = index.metricVals.get(metricName); if (holder == null) { return new FloatMetricSelector() { @Override public float get() { return 0.0f; } }; } cachedFloats = holder.getFloatType(); metricHolderCache.put(metricName, cachedFloats); } final IndexedFloats metricVals = cachedFloats; return new FloatMetricSelector() { @Override public float get() { return metricVals.get(cursorOffset.getOffset()); } }; } @Override public ComplexMetricSelector makeComplexMetricSelector(String metric) { final String metricName = metric.toLowerCase(); Indexed cachedComplex = (Indexed) metricHolderCache.get(metricName); if (cachedComplex == null) { MetricHolder holder = index.metricVals.get(metricName); if (holder != null) { cachedComplex = holder.getComplexType(); metricHolderCache.put(metricName, cachedComplex); } } if (cachedComplex == null) { return null; } final Indexed vals = cachedComplex; return new ComplexMetricSelector() { @Override public Class classOfObject() { return vals.getClazz(); } @Override public Object get() { return vals.get(cursorOffset.getOffset()); } }; } }; } }), new Runnable() { @Override public void run() { for (Object object : metricHolderCache.values()) { if (object instanceof Closeable) { Closeables.closeQuietly((Closeable) object); } } } }); } }; }