List of usage examples for org.joda.time DateTime withHourOfDay
public DateTime withHourOfDay(int hour)
From source file:org.opencastproject.index.service.catalog.adapter.DublinCoreMetadataUtil.java
License:Educational Community License
/** * Sets the start date in a dublin core catalog to the right value and keeps the start time and duration the same. * * @param dc//www .j a v a2s. com * The dublin core catalog to adjust * @param field * The metadata field that contains the start date. * @param ename * The EName in the catalog to identify the property that has the dublin core period. */ static void setTemporalStartDate(DublinCoreCatalog dc, MetadataField<?> field, EName ename) { if (field.getValue().isNone() || (field.getValue().get() instanceof String && StringUtils.isBlank(field.getValue().get().toString()))) { logger.debug("No value was set for metadata field with dublin core id '{}' and json id '{}'", field.getInputID(), field.getOutputID()); return; } try { // Get the current date SimpleDateFormat dateFormat = MetadataField.getSimpleDateFormatter(field.getPattern().get()); Date startDate = dateFormat.parse((String) field.getValue().get()); // Get the current period Opt<DCMIPeriod> period = getPeriodFromCatalog(dc, ename); // Get the current duration Long duration = getDuration(period); // Get the current start time hours, minutes and seconds DateTime currentStartTime = getCurrentStartTime(period); // Setup the new start time DateTime startDateTime = new DateTime(startDate.getTime()); startDateTime = startDateTime.withZone(DateTimeZone.UTC); startDateTime = startDateTime.withHourOfDay(currentStartTime.getHourOfDay()); startDateTime = startDateTime.withMinuteOfHour(currentStartTime.getMinuteOfHour()); startDateTime = startDateTime.withSecondOfMinute(currentStartTime.getSecondOfMinute()); // Get the current end date based on new date and duration. DateTime endDate = new DateTime(startDateTime.toDate().getTime() + duration); dc.set(ename, EncodingSchemeUtils.encodePeriod(new DCMIPeriod(startDateTime.toDate(), endDate.toDate()), Precision.Second)); } catch (ParseException e) { logger.error("Not able to parse date {} to update the dublin core because: {}", field.getValue(), ExceptionUtils.getStackTrace(e)); } }
From source file:org.opencastproject.index.service.catalog.adapter.DublinCoreMetadataUtil.java
License:Educational Community License
/** * Gets the current hour, minute and second from a dublin core period if available. * * @param period// w w w . j a v a 2 s . co m * The current period from dublin core. * @return A new DateTime with the current hour, minute and second. */ private static DateTime getCurrentStartDateTime(Opt<DCMIPeriod> period) { DateTime currentStartTime = new DateTime(); currentStartTime = currentStartTime.withZone(DateTimeZone.UTC); currentStartTime = currentStartTime.withYear(2001); currentStartTime = currentStartTime.withMonthOfYear(1); currentStartTime = currentStartTime.withDayOfMonth(1); currentStartTime = currentStartTime.withHourOfDay(0); currentStartTime = currentStartTime.withMinuteOfHour(0); currentStartTime = currentStartTime.withSecondOfMinute(0); if (period.isSome() && period.get().hasStart()) { DateTime fromDC = new DateTime(period.get().getStart().getTime()); fromDC = fromDC.withZone(DateTimeZone.UTC); currentStartTime = currentStartTime.withZone(DateTimeZone.UTC); currentStartTime = currentStartTime.withYear(fromDC.getYear()); currentStartTime = currentStartTime.withMonthOfYear(fromDC.getMonthOfYear()); currentStartTime = currentStartTime.withDayOfMonth(fromDC.getDayOfMonth()); currentStartTime = currentStartTime.withHourOfDay(fromDC.getHourOfDay()); currentStartTime = currentStartTime.withMinuteOfHour(fromDC.getMinuteOfHour()); currentStartTime = currentStartTime.withSecondOfMinute(fromDC.getSecondOfMinute()); } return currentStartTime; }
From source file:org.opensextant.extractors.xtemporal.DateNormalization.java
License:Apache License
/** * For now this reports only DATE and standard TIME fields. Timezone is * still TODO.// w w w . j a v a2 s .co m * * TODO: throw NormalizationException * * @param elements pattern fields * @param dt found date * @throws ParseException the parse exception */ public static void normalize_date(java.util.Map<String, String> elements, DateMatch dt) throws ParseException { // Parse years. int year = normalize_year(elements); if (year == INVALID_DATE) { return; } if (year > MAXIMUM_YEAR) { // HHMM can look like a year, e.g., 2100h or 2300 PM return; } dt.resolution = DateMatch.TimeResolution.YEAR; int month = normalize_month(elements); if (month == INVALID_DATE) { month = normalize_month_name(elements); } if (month == INVALID_DATE) { return; } DateTime _cal = new DateTime(year, month, 1, 0, 0, DateTimeZone.UTC); dt.resolution = DateMatch.TimeResolution.MONTH; int dom = normalize_day(elements); // If you got this far, then assume Day of Month is 1 (first of the month) if (dom == INVALID_DATE) { // No date found, resolution is month dom = 1; } else if (dom == 0) { return; } else { dt.resolution = DateMatch.TimeResolution.DAY; } // Normalize Time fields found, H, M, s.SSS, etc. // _cal = _cal.withDayOfMonth(dom); // For normal M/D/Y patterns, set the default time to noon, UTC // Overall, we want to ensure that the general yyyy-mm-dd form is not impacted // by time zone and default hour of 00:00; -- this generally would yield a date format a day early for ALL US timezones. // // Time res: the presence of a field, hh, mm, or ss means the pattern has that level of resolution. // So even if time is 00:00:00Z -- all zeroes -- the resolution is still SECONDS. // int hour = normalize_time(elements, "hh"); if (hour >= 0) { // Only if HH:MM... is present do we try to detect TZ. // DateTimeZone tz = normalize_tz(elements); if (tz != null) { _cal = _cal.withZone(tz); } // NON-zero hour. dt.resolution = DateMatch.TimeResolution.HOUR; int min = normalize_time(elements, "mm"); if (min >= 0) { dt.resolution = DateMatch.TimeResolution.MINUTE; // NON-zero minutes _cal = _cal.withHourOfDay(hour); _cal = _cal.withMinuteOfHour(min); } else { // No minutes _cal = _cal.withHourOfDay(hour); } } else { // No hour; default is 12:00 UTC. _cal = _cal.withHourOfDay(12); } dt.datenorm = new Date(_cal.getMillis()); }
From source file:org.projectbuendia.client.ui.chart.LocalizedChartDataGridAdapter.java
License:Apache License
public LocalizedChartDataGridAdapter(Context context, List<LocalizedObs> observations, LocalDate admissionDate, LocalDate firstSymptomsDate, LayoutInflater layoutInflater) { mContext = context;//from w w w. j av a 2s. c o m LocalizedChartHelper localizedChartHelper = new LocalizedChartHelper(context.getContentResolver()); mLayoutInflater = layoutInflater; Resources resources = context.getResources(); mAdmissionDate = admissionDate; mFirstSymptomsDate = firstSymptomsDate; // Even though these Drawables are currently identical, referencing different drawables // for row headers and table cells ensures that RecyclerView does not improperly reuse // one as the other. this.mBackgroundLight = resources.getDrawable(R.drawable.chart_grid_background_light); this.mBackgroundDark = resources.getDrawable(R.drawable.chart_grid_background_dark); this.mRowHeaderBackgroundLight = resources.getDrawable(R.drawable.chart_grid_row_header_background_light); this.mRowHeaderBackgroundDark = resources.getDrawable(R.drawable.chart_grid_row_header_background_dark); Row row = null; TreeSet<LocalDate> days = new TreeSet<>(); mToday = LocalDate.now(mChronology); for (LocalizedObs ob : observations) { // Observations come through ordered by the chart row, then the observation time, so we // want to maintain that order. if (row == null || !ob.conceptName.equals(row.mName)) { row = new Row(ob.conceptUuid, ob.conceptName); mRows.add(row); } if (ob.value == null || Concepts.UNKNOWN_UUID.equals(ob.value) || LocalizedChartHelper.NO_SYMPTOM_VALUES.contains(ob.value)) { // Don't display anything in the cell if there are no positive observations. continue; } DateTime obsDateTime = new DateTime(ob.encounterTimeMillis, mChronology); String columnId = toColumnId(obsDateTime); days.add(obsDateTime.toLocalDate()); LOG.v("Column: %s, Observation: %s", columnId, ob.toString()); if (row.mColumnIdsToLocalizedValues.containsKey(columnId)) { LOG.v("Overriding previous observation with value: %s", row.mColumnIdsToLocalizedValues.get(columnId)); } // If this is any bleeding site, also show a dot in the "any bleeding" row. if (Concepts.BLEEDING_SITES_NAME.equals(ob.groupName)) { mColumnIdsWithAnyBleeding.add(columnId); } // For notes, perform a concatenation rather than overwriting. if (Concepts.NOTES_UUID.equals(ob.conceptUuid)) { String oldText = row.mColumnIdsToValues.get(columnId); String newText = (oldText == null ? "" : oldText + "\n\n") + Dates.toMediumString(obsDateTime) + "\n" + ob.value; row.mColumnIdsToValues.put(columnId, newText); } else { row.mColumnIdsToValues.put(columnId, ob.value); } row.mColumnIdsToLocalizedValues.put(columnId, ob.localizedValue); } // Create the list of all the columns to show. Today and the admission date should // always be present, as well as any days between the last observation and today. days.add(mToday); if (admissionDate != null) { days.add(admissionDate); } LocalDate lastDay = days.last(); for (LocalDate d = days.first(); !d.isAfter(lastDay); d = d.plus(Days.ONE)) { DateTime dayStart = d.toDateTimeAtStartOfDay(); mColumnIds.add(toColumnId(dayStart)); mColumnIds.add(toColumnId(dayStart.withHourOfDay(12))); } // If there are no observations, put some known rows to make it clearer what is being // displayed. if (mRows.isEmpty()) { List<LocalizedObs> emptyChart = localizedChartHelper.getEmptyChart(LocalizedChartHelper.ENGLISH_LOCALE); for (LocalizedObs ob : emptyChart) { mRows.add(new Row(ob.conceptUuid, ob.conceptName)); } } }
From source file:org.vaadin.spring.samples.mvp.util.SSTimeUtil.java
License:Apache License
/** * <p/>/*from ww w . j a v a 2 s . c o m*/ * Gets a <code>day</code> and <code>hour</code> and transforms in to ISO * formatted date and time. Considers long and short day offset differences. * If it is a short day hour 1 {@link shortDayLabels} is in non DST hours * rest are in DST hours if it is a long day hour 1 {@link longDayLabels} is * in DST hours rest are in non DST hours, day hour 2 is handled like a * repeat of hour 1 except with a standard time offset. If <code>hour</code> * is "24" need to advance the day to the next day, i.e 24th hour of today * is 00th hour next day. * * @param day * day in ISO8601 String format (no millis) * @param hour * an hour returning from <code>labelsForDay</code> method * @return <p/> */ public static String getHourInIso(final String day, final String hour) { String result = null; if (day != null && hour != null) { DateTime dateTime = SSTimeUtil.isoDayToDateTime(day); String timeZoneOffset = timeZoneOffsetFormat.print(dateTime); String adjustedHour = hour; if (SSTimeUtil.hoursInDay(dateTime) < 24) { // short day // hour 1 should be in -06:00, rest should be in -05:00 if (hour.equals(shortDayLabels[0])) { timeZoneOffset = STANDARD_OFFSET; } else { timeZoneOffset = DST_OFFSET; } } else if (SSTimeUtil.hoursInDay(dateTime) > 24) { // long day // hour 1 should be in -05:00, hour 2 should be converted to // "01" // with -06:00 time zone offset, and rest should be in -06:00 if (hour.equals(longDayLabels[0])) { timeZoneOffset = DST_OFFSET; } else if (hour.equals(longDayLabels[1])) { timeZoneOffset = STANDARD_OFFSET; adjustedHour = "01"; } else { timeZoneOffset = STANDARD_OFFSET; } if (hour.contains("*")) { adjustedHour = hour.substring(0, 2);// remove "*02" timeZoneOffset = STANDARD_OFFSET; } } if (hour == "24") { adjustedHour = "00"; dateTime = dateTime.plusDays(1); } dateTime = dateTime.withHourOfDay(Integer.valueOf(adjustedHour)) .withZoneRetainFields(DateTimeZone.forID(timeZoneOffset)); result = isoFormat.print(dateTime); } return result; }
From source file:org.vaadin.spring.samples.mvp.util.SSTimeUtil.java
License:Apache License
/** * Calculate a minute interval based on an ISO8601 formatted String (no * millis), an hour label, and an interval label * * @param day//from w ww . j av a2 s .co m * an ISO8601 formatted String (no millis) * @param hour * an ending hour label (usually 01-24) * @param intervalLabel * an interval label (05, 10, 15, ...) * @return a minute interval from the start of the hour */ public static String getIntervalEndingInIso(final String day, final String hour, final String intervalLabel) { DateTime dateTime = isoToDateTime(day); dateTime = dateTime.withHourOfDay(Integer.parseInt(hour) - 1).plusMinutes(Integer.parseInt(intervalLabel)); return dateTimeToIsoNoMillis(dateTime); }
From source file:TVShowTimelineMaker.timeConstraints.ContainsConstraint.java
@Override public boolean consistentWithConstraint(T inFirstPlacement, S inSecondPlacement) { if (this.getContainsType().equals(ContainsType.CONTAINS)) { if (this.mContainsEvent instanceof OncePeriodEvent) { OncePeriodEvent.OncePeriodEventPlacement firstOncePeriodEventPlacement = (OncePeriodEvent.OncePeriodEventPlacement) inFirstPlacement; DateTime firstStartDate = firstOncePeriodEventPlacement.startDay.withHourOfDay(1); DateTime firstEndDate = firstOncePeriodEventPlacement.endDay.withHourOfDay(23); if (this.mContainedEvent instanceof OnceDayEvent) { OnceDayEvent.OnceDayEventPlacement secondOnceDayEventPlacement = (OnceDayEvent.OnceDayEventPlacement) inSecondPlacement; return firstStartDate.isBefore(secondOnceDayEventPlacement.day) && firstEndDate.isAfter(secondOnceDayEventPlacement.day); } else if (this.mContainedEvent instanceof YearlyDayEvent) { YearlyDayEvent.YearlyDayEventPlacement secondYearlyDayEventPlacement = (YearlyDayEvent.YearlyDayEventPlacement) inSecondPlacement; long lengh = new org.joda.time.Interval(firstStartDate, firstEndDate).toDuration() .getStandardDays(); if (lengh > 366) { return true; } else { DateTime lowDateTime = secondYearlyDayEventPlacement.day.toDateTime() .withYear(firstStartDate.getYear()); DateTime highDateTime = secondYearlyDayEventPlacement.day.toDateTime() .withYear(firstEndDate.getYear()); return (firstStartDate.isBefore(lowDateTime) && firstEndDate.isAfter(lowDateTime)) || (firstStartDate.isBefore(highDateTime) && firstEndDate.isAfter(highDateTime)); }/*from w ww .j a va2s . c o m*/ } else if (this.mContainedEvent instanceof OncePeriodEvent) { OncePeriodEvent.OncePeriodEventPlacement secondOncePeriodEventPlacement = (OncePeriodEvent.OncePeriodEventPlacement) inSecondPlacement; return firstStartDate.isBefore(secondOncePeriodEventPlacement.startDay) && firstEndDate.isAfter(secondOncePeriodEventPlacement.endDay); } else if (this.mContainedEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent.YearlyPeriodEventPlacement secondSeasonPlacement = (YearlyPeriodEvent.YearlyPeriodEventPlacement) inSecondPlacement; long lengh = new org.joda.time.Interval(firstStartDate, firstEndDate).toDuration() .getStandardDays(); if (lengh > 366) { return true; } else { DateTime lowStartDateTime = secondSeasonPlacement.startDay.toDateTime() .withYear(firstStartDate.getYear()); DateTime lowEndDateTime = secondSeasonPlacement.endDay.toDateTime() .withYear(firstStartDate.getYear()); DateTime highStartDateTime = secondSeasonPlacement.startDay.toDateTime() .withYear(firstEndDate.getYear()); DateTime highEndDateTime = secondSeasonPlacement.endDay.toDateTime() .withYear(firstEndDate.getYear()); return (firstStartDate.isBefore(lowStartDateTime) && firstEndDate.isAfter(lowEndDateTime)) || (firstStartDate.isBefore(highStartDateTime) && firstEndDate.isAfter(highEndDateTime)); } } else { return true; } } else if (this.mContainsEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent.YearlyPeriodEventPlacement firstSeasonPlacement = (YearlyPeriodEvent.YearlyPeriodEventPlacement) inFirstPlacement; if (this.mContainedEvent instanceof OnceDayEvent) { OnceDayEvent.OnceDayEventPlacement secondOnceDayEventPlacement = (OnceDayEvent.OnceDayEventPlacement) inSecondPlacement; DayOfYear tempDay = DayOfYear.fromDateTime(secondOnceDayEventPlacement.day); return firstSeasonPlacement.startDay.isEqualOrBefore(tempDay) && firstSeasonPlacement.endDay.isEqualOrAfter(tempDay); } else if (this.mContainedEvent instanceof YearlyDayEvent) { YearlyDayEvent.YearlyDayEventPlacement secondYearlyDayEventPlacement = (YearlyDayEvent.YearlyDayEventPlacement) inSecondPlacement; return firstSeasonPlacement.startDay.isEqualOrBefore(secondYearlyDayEventPlacement.day) && firstSeasonPlacement.endDay.isEqualOrAfter(secondYearlyDayEventPlacement.day); } else if (this.mContainedEvent instanceof OncePeriodEvent) { OncePeriodEvent.OncePeriodEventPlacement secondOncePeriodEventPlacement = (OncePeriodEvent.OncePeriodEventPlacement) inSecondPlacement; long lengh = new org.joda.time.Interval(secondOncePeriodEventPlacement.startDay, secondOncePeriodEventPlacement.endDay).toDuration().getStandardDays(); if (lengh > 366) { return true; } else { DayOfYear tempStartDay = DayOfYear.fromDateTime(secondOncePeriodEventPlacement.startDay); DayOfYear tempEndDay = DayOfYear.fromDateTime(secondOncePeriodEventPlacement.endDay); return firstSeasonPlacement.startDay.isEqualOrBefore(tempStartDay) && firstSeasonPlacement.endDay.isEqualOrAfter(tempEndDay); } } else if (this.mContainedEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent.YearlyPeriodEventPlacement secondSeasonPlacement = (YearlyPeriodEvent.YearlyPeriodEventPlacement) inSecondPlacement; return firstSeasonPlacement.startDay.isEqualOrBefore(secondSeasonPlacement.startDay) && firstSeasonPlacement.endDay.isEqualOrAfter(secondSeasonPlacement.endDay); } else { return true; } } else { return true; } } else { //todo: fill in if (this.mContainsEvent instanceof OncePeriodEvent) { OncePeriodEvent.OncePeriodEventPlacement firstOncePeriodEventPlacement = (OncePeriodEvent.OncePeriodEventPlacement) inFirstPlacement; DateTime firstStartDate = firstOncePeriodEventPlacement.startDay.withHourOfDay(23); DateTime firstEndDate = firstOncePeriodEventPlacement.endDay.withHourOfDay(2); if (this.mContainedEvent instanceof YearlyEvent) { org.joda.time.Interval newInterval = new org.joda.time.Interval(firstStartDate, firstEndDate); if (newInterval.toDuration().toStandardDays().getDays() >= 366) { return false; } } if (this.mContainedEvent instanceof OnceDayEvent) { OnceDayEvent.OnceDayEventPlacement secondOnceDayEventPlacement = (OnceDayEvent.OnceDayEventPlacement) inSecondPlacement; return secondOnceDayEventPlacement.day.isBefore(firstStartDate) || secondOnceDayEventPlacement.day.isAfter(firstEndDate); } else if (this.mContainedEvent instanceof YearlyDayEvent) { YearlyDayEvent.YearlyDayEventPlacement secondYearlyDayEventPlacement = (YearlyDayEvent.YearlyDayEventPlacement) inSecondPlacement; for (DateTime curDateTime = firstStartDate.withHourOfDay(1); curDateTime .isBefore(firstEndDate); curDateTime = curDateTime.plusDays(1)) { DayOfYear curDayOfYear = DayOfYear.fromDateTime(curDateTime); if (curDayOfYear.equals(secondYearlyDayEventPlacement.day)) { return false; } } } else if (this.mContainedEvent instanceof OncePeriodEvent) { OncePeriodEvent.OncePeriodEventPlacement secondOncePeriodEventPlacement = (OncePeriodEvent.OncePeriodEventPlacement) inSecondPlacement; return secondOncePeriodEventPlacement.endDay.isBefore(firstStartDate) || secondOncePeriodEventPlacement.startDay.isAfter(firstEndDate); } else if (this.mContainedEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent.YearlyPeriodEventPlacement secondSeasonPlacement = (YearlyPeriodEvent.YearlyPeriodEventPlacement) inSecondPlacement; java.util.Collection<DayOfYear> firstSet = new java.util.HashSet<>(1); java.util.Collection<DayOfYear> secondSet = new java.util.HashSet<>(1); for (DateTime curDateTime = firstStartDate.withHourOfDay(1); curDateTime .isBefore(firstEndDate); curDateTime = curDateTime.plusDays(1)) { DayOfYear curDayOfYear = DayOfYear.fromDateTime(curDateTime); firstSet.add(curDayOfYear); } for (DayOfYear curDayOfYear = secondSeasonPlacement.startDay; !curDayOfYear .equals(secondSeasonPlacement.endDay); curDayOfYear.plusDays(1)) { secondSet.add(curDayOfYear); } secondSet.add(secondSeasonPlacement.endDay); firstSet.retainAll(secondSet); if (!firstSet.isEmpty()) { return false; } } else { return true; } } else if (this.mContainsEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent.YearlyPeriodEventPlacement firstSeasonPlacement = (YearlyPeriodEvent.YearlyPeriodEventPlacement) inFirstPlacement; java.util.Collection<DayOfYear> firstSet = new java.util.HashSet<>(1); for (DayOfYear curDayOfYear = firstSeasonPlacement.startDay; !curDayOfYear .equals(firstSeasonPlacement.endDay); curDayOfYear.plusDays(1)) { firstSet.add(curDayOfYear); } if (this.mContainedEvent instanceof OnceDayEvent) { OnceDayEvent.OnceDayEventPlacement secondOnceDayEventPlacement = (OnceDayEvent.OnceDayEventPlacement) inSecondPlacement; if (firstSet.contains(DayOfYear.fromDateTime(secondOnceDayEventPlacement.day))) { return false; } } else if (this.mContainedEvent instanceof YearlyDayEvent) { YearlyDayEvent.YearlyDayEventPlacement secondYearlyDayEventPlacement = (YearlyDayEvent.YearlyDayEventPlacement) inSecondPlacement; if (firstSet.contains(secondYearlyDayEventPlacement.day)) { return false; } } else if (this.mContainedEvent instanceof OncePeriodEvent) { OncePeriodEvent.OncePeriodEventPlacement secondOncePeriodEventPlacement = (OncePeriodEvent.OncePeriodEventPlacement) inSecondPlacement; java.util.Collection<DayOfYear> secondSet = new java.util.HashSet<>(1); DateTime endDateTime = secondOncePeriodEventPlacement.endDay.withHourOfDay(23); for (DateTime curDateTime = secondOncePeriodEventPlacement.startDay.withHourOfDay( 1); curDateTime.isBefore(endDateTime); curDateTime = curDateTime.plusDays(1)) { DayOfYear curDayOfYear = DayOfYear.fromDateTime(curDateTime); secondSet.add(curDayOfYear); } firstSet.retainAll(secondSet); if (!firstSet.isEmpty()) { return false; } } else if (this.mContainedEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent.YearlyPeriodEventPlacement secondSeasonPlacement = (YearlyPeriodEvent.YearlyPeriodEventPlacement) inSecondPlacement; java.util.Collection<DayOfYear> secondSet = new java.util.HashSet<>(1); for (DayOfYear curDayOfYear = secondSeasonPlacement.startDay; !curDayOfYear .equals(secondSeasonPlacement.endDay); curDayOfYear.plusDays(1)) { secondSet.add(curDayOfYear); } secondSet.add(secondSeasonPlacement.endDay); firstSet.retainAll(secondSet); if (!firstSet.isEmpty()) { return false; } } else { return true; } } else { return true; } } return true; }
From source file:TVShowTimelineMaker.timeConstraints.PeriodToDayConstraint.java
@Override public boolean ConstraintSatisfied() { boolean con = true; if (this.getType() == PeriodToDayType.SAME_AS_START) { if (this.mPeriodEvent instanceof OncePeriodEvent) { OncePeriodEvent mOncePeriodEvent = (OncePeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; con = con// w ww.j a va 2s . c o m && (mOncePeriodEvent.getEarliestPossibleStartTime() .equals(mOnceDayEvent.getEarliestPossibleStartTime())) && (mOncePeriodEvent.getLatestPossibleStartTime() .equals(mOnceDayEvent.getLatestPossibleEndTime())); } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOncePeriodEvent.getLatestPossibleStartTime().withHourOfDay(23); for (DateTime curDay = mOncePeriodEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } con = con && days.containsAll(mYearlyDayEvent.getPossibleDays()); } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent mSeason = (YearlyPeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOnceDayEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOnceDayEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } con = con && days.containsAll(mSeason.getStartPossibleDays()); } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; con = con && mSeason.getStartPossibleDays().containsAll(mYearlyDayEvent.getPossibleDays()) && mYearlyDayEvent.getPossibleDays().containsAll(mSeason.getStartPossibleDays()); } } } else if (this.getType() == PeriodToDayType.SAME_AS_END) { if (this.mPeriodEvent instanceof OncePeriodEvent) { OncePeriodEvent mOncePeriodEvent = (OncePeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; con = con && (mOncePeriodEvent.getEarliestPossibleEndTime() .equals(mOnceDayEvent.getEarliestPossibleStartTime())) && (mOncePeriodEvent.getLatestPossibleEndTime() .equals(mOnceDayEvent.getLatestPossibleEndTime())); } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOncePeriodEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOncePeriodEvent.getEarliestPossibleEndTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } con = con && days.containsAll(mYearlyDayEvent.getPossibleDays()); } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent mSeason = (YearlyPeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOnceDayEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOnceDayEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } con = con && days.containsAll(mSeason.getEndPossibleDays()); } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; con = con && mSeason.getEndPossibleDays().containsAll(mYearlyDayEvent.getPossibleDays()) && mYearlyDayEvent.getPossibleDays().containsAll(mSeason.getEndPossibleDays()); } } } else if (this.getType() == PeriodToDayType.MIDDLE) { if (this.mPeriodEvent instanceof OncePeriodEvent) { OncePeriodEvent mOncePeriodEvent = (OncePeriodEvent) this.mPeriodEvent; org.joda.time.Interval mMiddleStartInterval = new org.joda.time.Interval( mOncePeriodEvent.getEarliestPossibleStartTime(), mOncePeriodEvent.getEarliestPossibleEndTime()); org.joda.time.Interval mMiddleEndInterval = new org.joda.time.Interval( mOncePeriodEvent.getLatestPossibleStartTime(), mOncePeriodEvent.getLatestPossibleEndTime()); int startDays = mMiddleStartInterval.toDuration().toStandardDays().getDays(); int endDays = mMiddleEndInterval.toDuration().toStandardDays().getDays(); DateTime MiddleStartTime = mOncePeriodEvent.getEarliestPossibleStartTime().plusDays(startDays / 2) .withHourOfDay(1); DateTime MiddleEndTime = mOncePeriodEvent.getLatestPossibleEndTime().minusDays(endDays / 2) .withHourOfDay(23); if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; con = con && (MiddleStartTime.equals(mOnceDayEvent.getEarliestPossibleStartTime())) && (MiddleEndTime.equals(mOnceDayEvent.getLatestPossibleEndTime())); } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = MiddleEndTime.withHourOfDay(23); for (DateTime curDay = MiddleStartTime.withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } con = con && days.containsAll(mYearlyDayEvent.getPossibleDays()); } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent mSeason = (YearlyPeriodEvent) this.mPeriodEvent; Set<DayOfYear> days1 = new java.util.HashSet<>( Math.max(mSeason.getStartPossibleDays().size(), mSeason.getEndPossibleDays().size())); //todo:make this mutiThreaded for (DayOfYear curDay1 : mSeason.getStartPossibleDays()) { for (DayOfYear curDay2 : mSeason.getEndPossibleDays()) { int diff = curDay1.diff(curDay2); int move = diff / 2; int rem = diff % 2; days1.add(curDay1.plusDays(move)); if (rem == 1) { days1.add(curDay1.plusDays(move + 1)); } } } if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; Set<DayOfYear> days2 = new java.util.HashSet<>(31); DateTime endDay = mOnceDayEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOnceDayEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days2.add(DayOfYear.fromDateTime(curDay)); } con = con && days2.containsAll(days1); } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; con = con && days1.containsAll(mYearlyDayEvent.getPossibleDays()) && mYearlyDayEvent.getPossibleDays().containsAll(days1); } } } return con; }
From source file:TVShowTimelineMaker.timeConstraints.PeriodToDayConstraint.java
@Override public boolean applyConstraint() { boolean changed = false; if (this.getType() == PeriodToDayType.SAME_AS_START) { if (this.mPeriodEvent instanceof OncePeriodEvent) { OncePeriodEvent mOncePeriodEvent = (OncePeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; if (mOncePeriodEvent.getEarliestPossibleStartTime() .isBefore(mOnceDayEvent.getEarliestPossibleStartTime())) { mOncePeriodEvent/*from w ww. ja va2s. c o m*/ .setEarliestPossibleDateForStart(mOnceDayEvent.getEarliestPossibleStartTime()); changed = true; } if (mOnceDayEvent.getEarliestPossibleStartTime() .isBefore(mOncePeriodEvent.getEarliestPossibleStartTime())) { mOnceDayEvent.setEarliestPossibleDate(mOncePeriodEvent.getEarliestPossibleStartTime()); changed = true; } if (mOncePeriodEvent.getLatestPossibleStartTime() .isAfter(mOnceDayEvent.getLatestPossibleEndTime())) { mOncePeriodEvent.setLatestPossibleDateForStart(mOnceDayEvent.getLatestPossibleEndTime()); changed = true; } if (mOnceDayEvent.getLatestPossibleEndTime() .isAfter(mOncePeriodEvent.getLatestPossibleStartTime())) { mOnceDayEvent.setLatestPossibleDate(mOncePeriodEvent.getLatestPossibleStartTime()); changed = true; } } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOncePeriodEvent.getLatestPossibleStartTime().withHourOfDay(23); for (DateTime curDay = mOncePeriodEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } if (!days.containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(days); changed = true; } } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent mSeason = (YearlyPeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOnceDayEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOnceDayEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } if (!days.containsAll(mSeason.getStartPossibleDays())) { mSeason.getStartPossibleDays().retainAll(days); changed = true; } if (!mSeason.getStartPossibleDays().isEmpty()) { int startYear = mOnceDayEvent.getEarliestPossibleStartTime().getYear(); DayOfYear curDayOfYear = DayOfYear .fromDateTime(mOnceDayEvent.getEarliestPossibleStartTime()); while (!mSeason.getStartPossibleDays().contains(curDayOfYear)) { curDayOfYear = curDayOfYear.plusDays(1); if (curDayOfYear.equals(DayOfYear.startOfYear)) { startYear++; } } DateTime oldDateTime = mOnceDayEvent.getEarliestPossibleStartTime(); mOnceDayEvent.setEarliestPossibleDate(curDayOfYear.toDateTime().withYear(startYear)); if (!mOnceDayEvent.getEarliestPossibleStartTime().equals(oldDateTime)) { changed = true; } int endYear = mOnceDayEvent.getLatestPossibleEndTime().getYear(); curDayOfYear = DayOfYear.fromDateTime(mOnceDayEvent.getLatestPossibleEndTime()); while (!mSeason.getStartPossibleDays().contains(curDayOfYear)) { curDayOfYear = curDayOfYear.plusDays(-1); if (curDayOfYear.equals(DayOfYear.endOfYear)) { endYear--; } } oldDateTime = mOnceDayEvent.getLatestPossibleEndTime(); mOnceDayEvent.setLatestPossibleDate(curDayOfYear.toDateTime().withYear(endYear)); if (!mOnceDayEvent.getLatestPossibleEndTime().equals(oldDateTime)) { changed = true; } } } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; if (mSeason.getStartPossibleDays().containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(mSeason.getStartPossibleDays()); changed = true; } if (mYearlyDayEvent.getPossibleDays().containsAll(mSeason.getStartPossibleDays())) { mSeason.getStartPossibleDays().retainAll(mYearlyDayEvent.getPossibleDays()); changed = true; } } } } else if (this.getType() == PeriodToDayType.SAME_AS_END) { if (this.mPeriodEvent instanceof OncePeriodEvent) { OncePeriodEvent mOncePeriodEvent = (OncePeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; if (mOncePeriodEvent.getEarliestPossibleEndTime() .isBefore(mOnceDayEvent.getEarliestPossibleStartTime())) { mOncePeriodEvent .setEarliestPossibleDateForEnd(mOnceDayEvent.getEarliestPossibleStartTime()); changed = true; } if (mOnceDayEvent.getEarliestPossibleStartTime() .isBefore(mOncePeriodEvent.getEarliestPossibleEndTime())) { mOnceDayEvent.setEarliestPossibleDate(mOncePeriodEvent.getEarliestPossibleEndTime()); changed = true; } if (mOncePeriodEvent.getLatestPossibleEndTime() .isAfter(mOnceDayEvent.getLatestPossibleEndTime())) { mOncePeriodEvent.setLatestPossibleDateForEnd(mOnceDayEvent.getLatestPossibleEndTime()); changed = true; } if (mOnceDayEvent.getLatestPossibleEndTime() .isAfter(mOncePeriodEvent.getLatestPossibleEndTime())) { mOnceDayEvent.setLatestPossibleDate(mOncePeriodEvent.getLatestPossibleEndTime()); changed = true; } } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOncePeriodEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOncePeriodEvent.getEarliestPossibleEndTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } if (!days.containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(days); changed = true; } } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent mSeason = (YearlyPeriodEvent) this.mPeriodEvent; if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = mOnceDayEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOnceDayEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } if (!days.containsAll(mSeason.getEndPossibleDays())) { mSeason.getEndPossibleDays().retainAll(days); changed = true; } if (!mSeason.getEndPossibleDays().isEmpty()) { int startYear = mOnceDayEvent.getEarliestPossibleStartTime().getYear(); DayOfYear curDayOfYear = DayOfYear .fromDateTime(mOnceDayEvent.getEarliestPossibleStartTime()); while (!mSeason.getEndPossibleDays().contains(curDayOfYear)) { curDayOfYear = curDayOfYear.plusDays(1); if (curDayOfYear.equals(DayOfYear.startOfYear)) { startYear++; } } DateTime oldDateTime = mOnceDayEvent.getEarliestPossibleStartTime(); mOnceDayEvent.setEarliestPossibleDate(curDayOfYear.toDateTime().withYear(startYear)); if (!mOnceDayEvent.getEarliestPossibleStartTime().equals(oldDateTime)) { changed = true; } int endYear = mOnceDayEvent.getLatestPossibleEndTime().getYear(); curDayOfYear = DayOfYear.fromDateTime(mOnceDayEvent.getLatestPossibleEndTime()); while (!mSeason.getEndPossibleDays().contains(curDayOfYear)) { curDayOfYear = curDayOfYear.plusDays(-1); if (curDayOfYear.equals(DayOfYear.endOfYear)) { endYear--; } } oldDateTime = mOnceDayEvent.getLatestPossibleEndTime(); mOnceDayEvent.setLatestPossibleDate(curDayOfYear.toDateTime().withYear(endYear)); if (!mOnceDayEvent.getLatestPossibleEndTime().equals(oldDateTime)) { changed = true; } } } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; if (mSeason.getEndPossibleDays().containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(mSeason.getEndPossibleDays()); changed = true; } if (mYearlyDayEvent.getPossibleDays().containsAll(mSeason.getEndPossibleDays())) { mSeason.getEndPossibleDays().retainAll(mYearlyDayEvent.getPossibleDays()); changed = true; } } } } else if (this.getType() == PeriodToDayType.MIDDLE) { if (this.mPeriodEvent instanceof OncePeriodEvent) { OncePeriodEvent mOncePeriodEvent = (OncePeriodEvent) this.mPeriodEvent; org.joda.time.Interval mMiddleStartInterval = new org.joda.time.Interval( mOncePeriodEvent.getEarliestPossibleStartTime(), mOncePeriodEvent.getEarliestPossibleEndTime()); org.joda.time.Interval mMiddleEndInterval = new org.joda.time.Interval( mOncePeriodEvent.getLatestPossibleStartTime(), mOncePeriodEvent.getLatestPossibleEndTime()); int startDays = mMiddleStartInterval.toDuration().toStandardDays().getDays(); int endDays = mMiddleEndInterval.toDuration().toStandardDays().getDays(); DateTime MiddleStartTime = mOncePeriodEvent.getEarliestPossibleStartTime().plusDays(startDays / 2) .withHourOfDay(1); DateTime MiddleEndTime = mOncePeriodEvent.getLatestPossibleEndTime().minusDays(endDays / 2) .withHourOfDay(23); if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; if (mOnceDayEvent.getEarliestPossibleStartTime().isBefore(MiddleStartTime)) { mOnceDayEvent.setEarliestPossibleDate(MiddleStartTime); changed = true; } if (mOnceDayEvent.getLatestPossibleEndTime().isAfter(MiddleEndTime)) { mOnceDayEvent.setLatestPossibleDate(MiddleEndTime); changed = true; } //Todo: change mOncePeriodEvent } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; Set<DayOfYear> days = new java.util.HashSet<>(31); DateTime endDay = MiddleEndTime.withHourOfDay(23); for (DateTime curDay = MiddleStartTime.withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days.add(DayOfYear.fromDateTime(curDay)); } if (days.containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(days); changed = true; } //Todo: change mOncePeriodEvent } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent mSeason = (YearlyPeriodEvent) this.mPeriodEvent; Set<DayOfYear> days1 = new java.util.HashSet<>( Math.max(mSeason.getStartPossibleDays().size(), mSeason.getEndPossibleDays().size())); //todo:make this mutiThreaded for (DayOfYear curDay1 : mSeason.getStartPossibleDays()) { for (DayOfYear curDay2 : mSeason.getEndPossibleDays()) { int diff = curDay1.diff(curDay2); int move = diff / 2; int rem = diff % 2; days1.add(curDay1.plusDays(move)); if (rem == 1) { days1.add(curDay1.plusDays(move + 1)); } } } if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; Set<DayOfYear> days2 = new java.util.HashSet<>(31); DateTime endDay = mOnceDayEvent.getLatestPossibleEndTime().withHourOfDay(23); for (DateTime curDay = mOnceDayEvent.getEarliestPossibleStartTime().withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days2.add(DayOfYear.fromDateTime(curDay)); } //TODO: change mSeason if (!days1.containsAll(days2)) { if (!days1.isEmpty()) { int startYear = mOnceDayEvent.getEarliestPossibleStartTime().getYear(); DayOfYear curDayOfYear = DayOfYear .fromDateTime(mOnceDayEvent.getEarliestPossibleStartTime()); while (!days1.contains(curDayOfYear)) { curDayOfYear = curDayOfYear.plusDays(1); if (curDayOfYear.equals(DayOfYear.startOfYear)) { startYear++; } } DateTime oldDateTime = mOnceDayEvent.getEarliestPossibleStartTime(); mOnceDayEvent.setEarliestPossibleDate(curDayOfYear.toDateTime().withYear(startYear)); if (!mOnceDayEvent.getEarliestPossibleStartTime().equals(oldDateTime)) { changed = true; } int endYear = mOnceDayEvent.getLatestPossibleEndTime().getYear(); curDayOfYear = DayOfYear.fromDateTime(mOnceDayEvent.getLatestPossibleEndTime()); while (!days1.contains(curDayOfYear)) { curDayOfYear = curDayOfYear.plusDays(-1); if (curDayOfYear.equals(DayOfYear.endOfYear)) { endYear--; } } oldDateTime = mOnceDayEvent.getLatestPossibleEndTime(); mOnceDayEvent.setLatestPossibleDate(curDayOfYear.toDateTime().withYear(endYear)); if (!mOnceDayEvent.getLatestPossibleEndTime().equals(oldDateTime)) { changed = true; } } } } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; if (!days1.containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(days1); changed = true; } //TODO: change mSeason if (mYearlyDayEvent.getPossibleDays().containsAll(days1)) { } } } } return changed; }
From source file:TVShowTimelineMaker.timeConstraints.PeriodToDayConstraint.java
@Override public boolean complexApplyConstraint() { boolean changed = this.applyConstraint(); if (this.mDayEvent.isMarkedForComplexEval() && (!this.mPeriodEvent.isMarkedForComplexEval())) { this.mPeriodEvent.setUpForComplexEval(); }/*ww w . j a v a 2s . c o m*/ if ((!this.mDayEvent.isMarkedForComplexEval()) && (this.mPeriodEvent.isMarkedForComplexEval())) { this.mDayEvent.setUpForComplexEval(); } if (this.mDayEvent.isMarkedForComplexEval() && this.mPeriodEvent.isMarkedForComplexEval()) { if (this.getType() == PeriodToDayType.SAME_AS_START) { SameTimeAsDayAcceptor startAcceptor = new SameTimeAsDayAcceptor(); startAcceptor.add(this.mDayEvent); startAcceptor.add(this.mPeriodEvent.getStart()); if (this.mPeriodEvent instanceof OncePeriodEvent) { java.util.Iterator<DateTime> i = ((OncePeriodEvent) this.mPeriodEvent).getStartPossibleDays() .iterator(); while (i.hasNext()) { DateTime curDay = i.next(); if (!startAcceptor.accept(curDay)) { i.remove(); } else if (!startAcceptor.accept2(curDay)) { i.remove(); } } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { java.util.Iterator<DayOfYear> i = ((YearlyPeriodEvent) this.mPeriodEvent).getStartPossibleDays() .iterator(); while (i.hasNext()) { DayOfYear curDay = i.next(); if (!startAcceptor.accept(curDay)) { i.remove(); } else if (!startAcceptor.accept2(curDay)) { i.remove(); } } } if (this.mDayEvent instanceof OnceDayEvent) { java.util.Iterator<DateTime> i = ((OnceDayEvent) this.mDayEvent).getPossibleDays().iterator(); while (i.hasNext()) { DateTime curDay = i.next(); if (!startAcceptor.accept(curDay)) { i.remove(); } else if (!startAcceptor.accept2(curDay)) { i.remove(); } } } else if (this.mDayEvent instanceof YearlyDayEvent) { java.util.Iterator<DayOfYear> i = ((YearlyDayEvent) this.mDayEvent).getPossibleDays() .iterator(); while (i.hasNext()) { DayOfYear curDay = i.next(); if (!startAcceptor.accept(curDay)) { i.remove(); } else if (!startAcceptor.accept2(curDay)) { i.remove(); } } } } else if (this.getType() == PeriodToDayType.SAME_AS_END) { SameTimeAsDayAcceptor endAcceptor = new SameTimeAsDayAcceptor(); endAcceptor.add(this.mDayEvent); endAcceptor.add(this.mPeriodEvent.getEnd()); if (this.mPeriodEvent instanceof OncePeriodEvent) { java.util.Iterator<DateTime> i = ((OncePeriodEvent) this.mPeriodEvent).getEndPossibleDays() .iterator(); while (i.hasNext()) { DateTime curDay = i.next(); if (!endAcceptor.accept(curDay)) { i.remove(); } else if (!endAcceptor.accept2(curDay)) { i.remove(); } } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { java.util.Iterator<DayOfYear> i = ((YearlyPeriodEvent) this.mPeriodEvent).getEndPossibleDays() .iterator(); while (i.hasNext()) { DayOfYear curDay = i.next(); if (!endAcceptor.accept(curDay)) { i.remove(); } else if (!endAcceptor.accept2(curDay)) { i.remove(); } } } if (this.mDayEvent instanceof OnceDayEvent) { java.util.Iterator<DateTime> i = ((OnceDayEvent) this.mDayEvent).getPossibleDays().iterator(); while (i.hasNext()) { DateTime curDay = i.next(); if (!endAcceptor.accept(curDay)) { i.remove(); } else if (!endAcceptor.accept2(curDay)) { i.remove(); } } } else if (this.mDayEvent instanceof YearlyDayEvent) { java.util.Iterator<DayOfYear> i = ((YearlyDayEvent) this.mDayEvent).getPossibleDays() .iterator(); while (i.hasNext()) { DayOfYear curDay = i.next(); if (!endAcceptor.accept(curDay)) { i.remove(); } else if (!endAcceptor.accept2(curDay)) { i.remove(); } } } } else if (this.getType() == PeriodToDayType.MIDDLE) { if (this.mPeriodEvent instanceof OncePeriodEvent) { OncePeriodEvent mOncePeriodEvent = (OncePeriodEvent) this.mPeriodEvent; org.joda.time.Interval mMiddleStartInterval = new org.joda.time.Interval( mOncePeriodEvent.getEarliestPossibleStartTime(), mOncePeriodEvent.getEarliestPossibleEndTime()); org.joda.time.Interval mMiddleEndInterval = new org.joda.time.Interval( mOncePeriodEvent.getLatestPossibleStartTime(), mOncePeriodEvent.getLatestPossibleEndTime()); int startDays = mMiddleStartInterval.toDuration().toStandardDays().getDays(); int endDays = mMiddleEndInterval.toDuration().toStandardDays().getDays(); DateTime MiddleStartTime = mOncePeriodEvent.getEarliestPossibleStartTime() .plusDays(startDays / 2).withHourOfDay(1); DateTime MiddleEndTime = mOncePeriodEvent.getLatestPossibleEndTime().minusDays(endDays / 2) .withHourOfDay(23); Set<DateTime> days1 = new java.util.HashSet<>(31); for (DateTime curDay = MiddleStartTime; curDay .isBefore(MiddleEndTime); curDay = curDay.plusDays(1)) { days1.add(curDay); } if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; if (!days1.containsAll(mOnceDayEvent.getPossibleDays())) { mOnceDayEvent.getPossibleDays().retainAll(days1); } //Todo: change mOncePeriodEvent } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; Set<DayOfYear> days2 = new java.util.HashSet<>(31); DateTime endDay = MiddleEndTime.withHourOfDay(23); for (DateTime curDay = MiddleStartTime.withHourOfDay(1); curDay .isBefore(endDay); curDay = curDay.plusDays(1)) { days2.add(DayOfYear.fromDateTime(curDay)); } if (days2.containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(days2); } //Todo: change mOncePeriodEvent } } else if (this.mPeriodEvent instanceof YearlyPeriodEvent) { YearlyPeriodEvent mSeason = (YearlyPeriodEvent) this.mPeriodEvent; Set<DayOfYear> days1 = new java.util.HashSet<>( Math.max(mSeason.getStartPossibleDays().size(), mSeason.getEndPossibleDays().size())); //todo:make this mutiThreaded for (DayOfYear curDay1 : mSeason.getStartPossibleDays()) { for (DayOfYear curDay2 : mSeason.getEndPossibleDays()) { int diff = curDay1.diff(curDay2); int move = diff / 2; int rem = diff % 2; days1.add(curDay1.plusDays(move)); if (rem == 1) { days1.add(curDay1.plusDays(move + 1)); } } } if (this.mDayEvent instanceof OnceDayEvent) { OnceDayEvent mOnceDayEvent = (OnceDayEvent) this.mDayEvent; Set<DayOfYear> days2 = new java.util.HashSet<>(31); for (DateTime curDay : mOnceDayEvent.getPossibleDays()) { days2.add(DayOfYear.fromDateTime(curDay)); } //TODO: change mSeason if (!days1.containsAll(days2)) { Iterator<DateTime> onceEventIterator = mOnceDayEvent.getPossibleDays().iterator(); while (onceEventIterator.hasNext()) { DateTime curDay = onceEventIterator.next(); if (!days1.contains(DayOfYear.fromDateTime(curDay))) { onceEventIterator.remove(); } } } } else if (this.mDayEvent instanceof YearlyDayEvent) { YearlyDayEvent mYearlyDayEvent = (YearlyDayEvent) this.mDayEvent; if (days1.containsAll(mYearlyDayEvent.getPossibleDays())) { mYearlyDayEvent.getPossibleDays().retainAll(days1); } //TODO: change mSeason if (mYearlyDayEvent.getPossibleDays().containsAll(days1)) { } } } } } return changed; }