Example usage for org.joda.time Interval Interval

Introduction

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

Prototype

public Interval(Object interval, Chronology chronology)

Source Link

Document

Constructs a time interval by converting or copying from another object, overriding the chronology.

Usage

From source file:net.lshift.diffa.config.BoundedTimeInterval.java

License:Apache License

public Interval toJodaInterval() {
    if (jodaInterval == null) {
        String iStart = isOpen(start) ? String.valueOf(TimeInterval.MIN_YEAR) : start;
        String iEnd = isOpen(end) ? String.valueOf(TimeInterval.MAX_YEAR) : end;

        jodaInterval = new Interval(parseDateTime(iStart), parseDateTime(iEnd));
    }/*from  w ww. j  a  v a  2 s. c o m*/

    return jodaInterval;
}

From source file:net.lshift.diffa.config.WindowRefiner.java

License:Apache License

private WindowRefiner(String periodExpression, String offsetExpression, DateTime now) {
    this.periodExpression = periodExpression;
    this.offsetExpression = offsetExpression;

    DateTime end;/*from   ww w .  j a v a  2s  .  com*/
    if (offsetExpression == null || offsetExpression.equals("")) {
        end = now;
    } else {
        DateTime startOfDay = now.toDateMidnight().toDateTime();
        end = startOfDay.plus(periodFormatter.parsePeriod(offsetExpression).toDurationFrom(startOfDay));
    }
    DateTime start = end.minus(periodFormatter.parsePeriod(periodExpression));
    this.windowInterval = new Interval(start, end);
}

From source file:net.oauth.jsontoken.SystemClock.java

License:Apache License

/**
 * Determines whether the current time (plus minus the acceptableClockSkew) falls within the
 * interval defined by the start and intervalLength parameters.
 */// w  w  w .jav a 2  s.c  o  m
@Override
public boolean isCurrentTimeInInterval(Instant start, Instant end) {
    Interval interval = new Interval(start, end);
    Instant now = now();
    Interval currentTimeWithSkew = new Interval(now.minus(acceptableClockSkew), now.plus(acceptableClockSkew));
    return interval.overlaps(currentTimeWithSkew);
}

From source file:net.rrm.ehour.data.DateRange.java

License:Open Source License

public Interval toInterval() {
    Date start = getDateStart();//from w ww.  j av  a2 s .  c  o  m
    Date end = getDateEnd();
    return new Interval(start != null ? new DateTime(start) : new DateTime().minusYears(100),
            end != null ? new DateTime(end) : new DateTime().plusYears(100));

}

From source file:net.rrm.ehour.util.DateUtil.java

License:Open Source License

/**
 * Converts a calendar to a range covering that month
 *
 * @return first Calendar object is start of the month, last Calendar object is end of the month
 *///  w  w w . j a  v a  2 s  .c om
public static DateRange calendarToMonthRange(Calendar calendar) {

    DateTime date = new DateTime(calendar);

    return new DateRange(new Interval(date.withDayOfMonth(1), date.withDayOfMonth(getDaysInMonth(date))));
}

From source file:net.schweerelos.parrot.model.filters.IntervalChainBasedFilter.java

License:Open Source License

protected boolean matches(NodeWrapper nodeWrapper) {
    if (intervals == null) {
        Logger logger = Logger.getLogger(IntervalChainBasedFilter.class);
        logger.warn("no intervals!");
        return false;
    }/*from w  w w. j  a  v a 2  s. c  om*/
    if (!nodeWrapper.isOntResource()) {
        return false;
    }
    OntResource node = nodeWrapper.getOntResource();
    if (!TimedThingsHelper.isTimedThing(node, model)) {
        return false;
    }
    try {
        DateTime startsAt = TimedThingsHelper.extractStartDate(node, model);
        DateTime endsAt = TimedThingsHelper.extractEndDate(node, model);
        return intervals.contains(new Interval(startsAt, endsAt));
    } catch (NotTimedThingException ntte) {
        return false;
    }
}

From source file:net.schweerelos.parrot.model.filters.TimeBasedFilter.java

License:Open Source License

@Override
protected boolean matches(NodeWrapper nodeWrapper) {
    boolean timedThing = false;
    boolean inInterval = false;

    if (interval == null) {
        Logger logger = Logger.getLogger(TimeBasedFilter.class);
        logger.warn("no interval!");
        inInterval = true;//from ww  w .  j  a v a2s . co  m
        return accept(timedThing, inInterval);
    }
    if (!nodeWrapper.isOntResource()) {
        timedThing = false;
        return accept(timedThing, inInterval);
    }
    OntResource node = nodeWrapper.getOntResource();
    if (!TimedThingsHelper.isTimedThing(node, model)) {
        timedThing = false;
        return accept(timedThing, inInterval);
    }

    try {
        timedThing = true;
        DateTime startsAt = TimedThingsHelper.extractStartDate(node, model);
        DateTime endsAt = TimedThingsHelper.extractEndDate(node, model);
        inInterval = interval.contains(new Interval(startsAt, endsAt));
        return accept(timedThing, inInterval);
    } catch (NotTimedThingException ntte) {
        timedThing = false;
        return accept(timedThing, inInterval);
    }
}

From source file:net.schweerelos.parrot.model.TimedThingsHelper.java

License:Open Source License

public static IntervalChain<NodeWrapper> extractTimedThings(ParrotModel pModel) {
    OntModel model = pModel.getOntModel();
    Resource timedThingClass = model.createClass(TIMED_THING);

    IntervalChain<NodeWrapper> timelineModel = new IntervalChain<NodeWrapper>();
    ExtendedIterator<Individual> instances = model.listIndividuals(timedThingClass);
    while (instances.hasNext()) {
        Individual instance = instances.next();
        final NodeWrapper node = pModel.getNodeWrapper(instance);

        DateTime startsAt;/* ww w.java2s .  c  o  m*/
        DateTime endsAt;
        try {
            startsAt = extractStartDate(instance, model);
        } catch (NotTimedThingException e) {
            // ignore this individual
            continue;
        }
        try {
            endsAt = extractEndDate(instance, model);
        } catch (NotTimedThingException e) {
            // ignore this individual
            continue;
        }

        if (startsAt == null || endsAt == null) {
            // only proceed if we have a start time *and* an end time
            continue;
        }

        if (endsAt.isBefore(startsAt)) {
            System.out.printf(
                    "end timestamp %s is before start timestamp %s, ignoring instance %s as TimedThing\n",
                    endsAt.toString(), startsAt.toString(), instance.getURI());
            continue;
        }
        final Interval base = new Interval(startsAt, endsAt);

        PayloadInterval<NodeWrapper> interval = new PayloadInterval<NodeWrapper>() {
            Interval baseInterval = base;

            @Override
            public DateTime getEnd() {
                return baseInterval.getEnd();
            }

            @Override
            public DateTime getStart() {
                return baseInterval.getStart();
            }

            @Override
            public NodeWrapper getPayload() {
                return node;
            }

            @Override
            public boolean contains(Interval interval) {
                return baseInterval.contains(interval);
            }

            @Override
            public Interval toInterval() {
                return baseInterval;
            }

        };
        timelineModel.add(interval);
    }
    return timelineModel;
}

From source file:net.schweerelos.timeline.model.Timeline.java

License:Open Source License

private void recalculate() {
    if (start == null || end == null) {
        logger.warn("recalculating aborted, start and/or end is null");
        numSlices = 0;//from  ww w.  j a v a2 s. c  om
        return;
    }
    Interval interval = new Interval(start, end);

    if (Years.yearsIn(interval).isGreaterThan(Years.ZERO)) {
        // make it start at the start of the current increment mode
        start = start.withDayOfYear(start.dayOfYear().getMinimumValue());
        end = end.withDayOfYear(end.dayOfYear().getMaximumValue());
        interval = new Interval(start, end);

        // figure out number of slices
        numSlices = Years.yearsIn(interval).getYears();
        if (start.plusYears(numSlices).isBefore(end)) {
            numSlices += 1;
        }

        // update label extractor
        sliceLabelExtractor = new SliceLabelExtractor() {
            @Override
            public String extractLabel(DateTime from) {
                return from.year().getAsShortText();
            }
        };

        // update increment
        increment = Years.ONE.toPeriod();
        incrementMode = Mode.Years;
    } else if (Months.monthsIn(interval).isGreaterThan(Months.ZERO)) {
        // make it start at the start of the current increment mode
        start = start.withDayOfMonth(start.dayOfMonth().getMinimumValue());
        end = end.withDayOfMonth(end.dayOfMonth().getMaximumValue());
        interval = new Interval(start, end);

        numSlices = Months.monthsIn(interval).getMonths();
        if (start.plusMonths(numSlices).isBefore(end)) {
            numSlices += 1;
        }

        sliceLabelExtractor = new SliceLabelExtractor() {
            @Override
            public String extractLabel(DateTime from) {
                return from.monthOfYear().getAsShortText();
            }
        };

        increment = Months.ONE.toPeriod();
        incrementMode = Mode.Months;
    } else if (Weeks.weeksIn(interval).isGreaterThan(Weeks.ZERO)) {
        start = start.withDayOfWeek(start.dayOfWeek().getMinimumValue());
        end = end.withDayOfWeek(end.dayOfWeek().getMaximumValue());
        interval = new Interval(start, end);

        numSlices = Weeks.weeksIn(interval).getWeeks();
        if (start.plusWeeks(numSlices).isBefore(end)) {
            numSlices += 1;
        }

        sliceLabelExtractor = new SliceLabelExtractor() {
            @Override
            public String extractLabel(DateTime from) {
                return "W" + from.weekOfWeekyear().getAsShortText();
            }
        };

        increment = Weeks.ONE.toPeriod();
        incrementMode = Mode.Weeks;
    } else {
        numSlices = Days.daysIn(interval).getDays();
        if (start.plusDays(numSlices).isBefore(end)) {
            numSlices += 1;
        }
        if (numSlices == 0) {
            // force at least one day to be drawn
            numSlices = 1;
        }

        sliceLabelExtractor = new SliceLabelExtractor() {
            @Override
            public String extractLabel(DateTime from) {
                return from.dayOfMonth().getAsShortText();
            }
        };

        increment = Days.ONE.toPeriod();
        incrementMode = Mode.Days;
    }

    // reset time of day too
    start = start.withMillisOfDay(start.millisOfDay().getMinimumValue());
    end = end.withMillisOfDay(end.millisOfDay().getMaximumValue());

    // recalculate which intervals are within range
    intervalsWithinRange.clear();
    intervalsWithinRange.addAll(calculateIntervalsWithinRange(start, end));

    // notify listeners
    changeSupport.firePropertyChange(INTERVAL_PROPERTY_KEY, interval, new Interval(start, end));
}

From source file:net.schweerelos.timeline.model.Timeline.java

License:Open Source License

private Set<PayloadInterval<T>> calculateIntervalsWithinRange(DateTime rangeStart, DateTime rangeEnd) {
    Set<PayloadInterval<T>> result = new HashSet<PayloadInterval<T>>();
    Interval range = new Interval(rangeStart, rangeEnd);
    for (PayloadInterval<T> interval : allIntervals) {
        if (range.contains(interval.getStart()) && range.contains(interval.getEnd())) {
            result.add(interval);//from   w w w . j  a  va 2  s . c om
        }
    }
    return result;
}