Package types.collections.time

Class dateset

java.lang.Object
types.collections.base.Set<LocalDate>
types.collections.time.dateset
All Implemented Interfaces:
Base, Collection, Time, TimeCollection, TemporalObject
public class dateset extends Set<LocalDate> implements Time, TimeCollection
Class for representing lists of distinct dates.

``DateSet`` objects can be created with a single argument of type string as in MobilityDB.

>>> DateSet(string='{2019-09-08, 2019-09-10, 2019-09-11}')

Another possibility is to give a tuple or list of composing dates, which can be instances of ``str`` or ``date``. The composing dates must be given in increasing order.

>>> DateSet(elements=['2019-09-08', '2019-09-10', '2019-09-11'])
>>> DateSet(elements=[parse('2019-09-08'), parse('2019-09-10'), parse('2019-09-11')])

Author:
ARIJIT SAMAL

  • Field Details

    • _inner

      private final jnr.ffi.Pointer _inner

  • Constructor Details

    • dateset

      public dateset(jnr.ffi.Pointer inner)

    • dateset

      public dateset(String value)

    • dateset

      public dateset(List<LocalDate> dates)

  • Method Details

    • duration

      public Duration duration() throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException
      Returns the duration of the time ignoring gaps, i.e. the duration from the first timestamp to the last one. Returns: A :class:`datetime.timedelta` instance representing the duration of ``self`` MEOS Functions: tstzspan_duration
      Throws:
      InvocationTargetException
      NoSuchMethodException
      InstantiationException
      IllegalAccessException

    • createInner

      public jnr.ffi.Pointer createInner(jnr.ffi.Pointer inner)
      Specified by:
      createInner in class Set<LocalDate>

    • createStringInner

      public jnr.ffi.Pointer createStringInner(String str)
      Specified by:
      createStringInner in class Set<LocalDate>

    • get_inner

      public jnr.ffi.Pointer get_inner()
      Specified by:
      get_inner in class Set<LocalDate>

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • date_adt_to_date

      public LocalDate date_adt_to_date(int ts)
      Function to convert the integer timestamp to LocalDate format so that it can be used by other libraries

    • start_element

      public LocalDate start_element() throws org.locationtech.jts.io.ParseException
      Returns the first date in ``self``. Returns: A :class:`date` instance MEOS Functions: dateset_start_value
      Specified by:
      start_element in class Set<LocalDate>
      Returns:
      A Set instance
      Throws:
      org.locationtech.jts.io.ParseException

    • end_element

      public LocalDate end_element() throws org.locationtech.jts.io.ParseException
      Returns the last date in ``self``. Returns: A :class:`date` instance MEOS Functions: dateset_end_value
      Specified by:
      end_element in class Set<LocalDate>
      Returns:
      A Set instance
      Throws:
      org.locationtech.jts.io.ParseException

    • element_n

      public LocalDate element_n(int n) throws Exception
      Returns the n-th date in ``self``. Returns: A :class:`date` instance MEOS Functions: dateset_value_n
      Overrides:
      element_n in class Set<LocalDate>
      Parameters:
      n - the n-th element
      Returns:
      A Set instance
      Throws:
      Exception

    • elements

      public List<LocalDate> elements() throws Exception
      Returns the list of distinct dates in ``self``. Returns: A :class:`list[date]` instance MEOS Functions: dateset_values
      Throws:
      Exception

    • scale

      public dateset scale(Integer duration)
      Returns a new :class:`DateSet` that with the scaled so that the span of ``self`` is ``duration``. Examples: >>> DateSet('{2000-01-01, 2000-01-10}').scale(timedelta(days=2)) >>> 'DateSet({2000-01-01, 2000-01-03})' Args: duration: :class:`datetime.timedelta` instance representing the span of the new set Returns: A new :class:`DateSet` instance MEOS Functions: dateset_shift_scale

    • shift

      public dateset shift(Integer shift)
      Returns a new :class:`DateSpanSet` that is the result of shifting ``self`` by ``delta`` Examples: >>> DateSet('{2000-01-01, 2000-01-10}').shift(timedelta(days=2)) >>> 'DateSet({2000-01-03, 2000-01-12})' Args: delta: :class:`datetime.timedelta` instance to shift Returns: A new :class:`DateSpanSet` instance MEOS Functions: dateset_shift_scale

    • shift_scale

      public dateset shift_scale(Integer shift, Integer duration)
      Returns a new :class:`DateSet` that is the result of shifting and scaling ``self``. Examples: >>> DateSet('{2000-01-01, 2000-01-10}').shift_scale(shift=timedelta(days=2), duration=timedelta(days=4)) >>> 'DateSet({2000-01-03, 2000-01-07})' Args: shift: :class:`datetime.timedelta` instance to shift duration: :class:`datetime.timedelta` instance representing the span of the new set Returns: A new :class:`DateSet` instance MEOS Functions: dateset_shift_scale

    • dateToTimestamp

      public int dateToTimestamp(LocalDate date)
      Returns whether ``self`` temporally contains ``content``. Examples: >>> DateSet('{2012-01-01, 2012-01-04}').contains(parse('2012-01-01').date()) >>> True >>> DateSet('{2012-01-01, 2012-01-02}').contains(DateSet('{2012-01-01}')) >>> True >>> DateSet('{2012-01-01, 2012-01-02}').contains(DateSet('{2012-01-01, 2012-01-03}')) >>> False Args: content: temporal object to compare with Returns: True if contains, False otherwise MEOS Functions: contains_set_date, contains_set_set, contains_spanset_spanset

    • contains

      public boolean contains(Object other) throws Exception
      Throws:
      Exception

    • overlaps

      public boolean overlaps(Object other) throws Exception
      Returns whether ``self`` temporally overlaps ``other``. That is, both share at least an instant Examples: >>> DateSet('{2012-01-01, 2012-01-02}').overlaps(DateSet('{2012-01-02, 2012-01-03}')) >>> True >>> DateSet('{2012-01-01, 2012-01-02}').overlaps(DateSpan('[2012-01-02, 2012-01-03]')) >>> True >>> DateSet('{2012-01-01, 2012-01-02}').overlaps(DateSpan('(2012-01-02, 2012-01-03]')) >>> False Args: other: temporal object to compare with Returns: True if overlaps, False otherwise MEOS Functions: overlaps_set_set, overlaps_span_span, overlaps_spanset_spanset
      Throws:
      Exception

    • is_left

      public boolean is_left(Object other) throws Exception
      Returns whether ``self`` is strictly before ``other``. That is, ``self`` ends before ``other`` starts. Examples: >>> DateSet('{2012-01-01, 2012-01-02}').is_left(DateSet('{2012-01-03}')) >>> True >>> DateSet('{2012-01-01, 2012-01-02}').is_left(DateSpan('(2012-01-02, 2012-01-03]')) >>> True >>> DateSet('{2012-01-01, 2012-01-02}').is_left(DateSpan('[2012-01-02, 2012-01-03]')) >>> False Args: other: temporal object to compare with Returns: True if before, False otherwise MEOS Functions: before_set_date, left_span_span
      Throws:
      Exception

    • is_over_or_left

      public boolean is_over_or_left(Object other) throws Exception
      Returns whether ``self`` is before ``other`` allowing overlap. That is, ``self`` ends before ``other`` ends (or at the same time). Examples: >>> DateSet('{2012-01-01, 2012-01-02}').is_over_or_left(DateSpan('[2012-01-02, 2012-01-03]')) >>> True >>> DateSet('{2012-01-01, 2012-01-02}').is_over_or_left(DateSpan('[2012-01-02, 2012-01-03]')) >>> True >>> DateSet('{2012-01-03, 2012-01-05}').is_over_or_left(DateSpan('[2012-01-01, 2012-01-04]')) >>> False Args: other: temporal object to compare with Returns: True if before, False otherwise MEOS Functions: overbefore_set_date, overleft_span_span, overleft_span_spanset
      Throws:
      Exception

    • is_over_or_right

      public boolean is_over_or_right(Object other) throws Exception
      Returns whether ``self`` is after ``other`` allowing overlap. That is, ``self`` starts after ``other`` starts (or at the same time). Examples: >>> DateSet('{2012-01-02, 2012-01-03}').is_over_or_right(DateSpan('[2012-01-01, 2012-01-02)')) >>> True >>> DateSet('{2012-01-02, 2012-01-03}').is_over_or_right(DateSpan('[2012-01-01, 2012-01-02]')) >>> True >>> DateSet('{2012-01-02, 2012-01-03}').is_over_or_right(DateSpan('[2012-01-01, 2012-01-03]')) >>> False Args: other: temporal object to compare with Returns: True if overlapping or after, False otherwise MEOS Functions: overafter_set_date, overright_span_span, overright_span_spanset
      Throws:
      Exception

    • is_right

      public boolean is_right(Object other) throws Exception
      Returns whether ``self`` is strictly after ``other``. That is, the first timestamp in ``self`` is after ``other``. Examples: >>> DateSet('{2012-01-02, 2012-01-03}').is_right(DateSpan('[2012-01-01, 2012-01-02)')) >>> True >>> DateSet('{2012-01-02, 2012-01-03}').is_right(DateSet('{2012-01-01}')) >>> True >>> DateSet('{2012-01-02, 2012-01-03}').is_right(DateSpan('[2012-01-01, 2012-01-02]')) >>> False Args: other: temporal object to compare with Returns: True if after, False otherwise MEOS Functions: after_set_date, right_span_span, right_span_spanset
      Throws:
      Exception

    • is_before

      public boolean is_before(Object other) throws Exception
      Specified by:
      is_before in interface TimeCollection
      Throws:
      Exception

    • is_over_or_before

      public boolean is_over_or_before(Object other) throws Exception
      Specified by:
      is_over_or_before in interface TimeCollection
      Throws:
      Exception

    • is_over_or_after

      public boolean is_over_or_after(Object other) throws Exception
      Specified by:
      is_over_or_after in interface TimeCollection
      Throws:
      Exception

    • is_after

      public boolean is_after(Object other) throws Exception
      Specified by:
      is_after in interface TimeCollection
      Throws:
      Exception

    • distance

      public Duration distance(Object other) throws Exception
      Returns the temporal distance between ``self`` and ``other``. Args: other: temporal object to compare with Returns: A :class:`datetime.timedelta` instance MEOS Functions: distance_set_date, distance_dateset_dateset, distance_datespanset_datespan, distance_datespanset_datespanset
      Throws:
      Exception

    • timestampToLocalDateTime

      public static LocalDateTime timestampToLocalDateTime(int timestamp)

    • intersection

      public LocalDateTime intersection(Object other) throws Exception
      Returns the temporal intersection of ``self`` and ``other``. Args: other: temporal object to intersect with Returns: A :class:`TimeDate` instance. The actual class depends on ``other``. MEOS Functions: intersection_set_date, intersection_set_set, intersection_spanset_span, intersection_spanset_spanset
      Throws:
      Exception

    • minus

      public LocalDateTime minus(Object other) throws Exception
      Returns the temporal difference of ``self`` and ``other``. Args: other: temporal object to diff with Returns: A :class:`TimeDate` instance. The actual class depends on ``other``. MEOS Functions: minus_set_date, minus_set_set, minus_spanset_span, minus_spanset_spanset
      Throws:
      Exception

    • timestampToLocalDate

      public static LocalDate timestampToLocalDate(int timestamp)
      Convert timestamp (number of seconds since epoch) to LocalDate

    • subtract_from

      public LocalDate subtract_from(Object other) throws Exception
      Throws:
      Exception

    • union

      public dateset union(Object other) throws Exception
      Returns the temporal union of ``self`` and ``other``. Args: other: temporal object to merge with Returns: A :class:`TimeDate` instance. The actual class depends on ``other``. MEOS Functions: union_set_date, union_set_set, union_spanset_span, union_spanset_spanset
      Throws:
      Exception