tupelo.java-time — tupelo 22.02.09

*zone-id* clj

->year-quarter clj

(->year-quarter arg)

Inputs: [arg] Returns: tsk/Quarter

Given a date-ish value (e.g. LocalDate, et al), returns the quarter of the year as one of #{ :Q1 :Q2 :Q3 :Q4 }

between clj

(between chrono-unit t1 t2)

Inputs: [chrono-unit :- ChronoUnit t1 :- Temporal t2 :- Temporal] Returns: s/Int

Returns the integer number of ChronoUnit values between two temporal values, truncating any fraction. Example:

  (let [i1      (->Instant "1987-11-22t01:30:00z")
        i2      (->Instant "1987-11-22t03:29:00z")
        delta   (between ChronoUnit/HOURS i1 i2) ]  ...)

yields delta=1 since 1hr 59min is truncated to 1 hour.

esec->Instant clj

(esec->Instant esec)

Wrapper for java.time.Instant/ofEpochSecs

fixed-time-point? clj

(fixed-time-point? it)

Returns true iff arg represents a fixed point in time. Examples:

[java.time ZonedDateTime Instant] [org.joda.time DateTime Instant ReadableInstant]

format->iso-str clj

(format->iso-str inst)

Inputs: [inst :- Temporal] Returns: s/Str

Given an Instant or ZonedDateTime, returns a ISO 8601 datetime string like 2018-09-05T23:05:19.123Z

format->iso-str-nice clj

(format->iso-str-nice inst)

Inputs: [inst :- Temporal] Returns: s/Str

Given an Instant or ZonedDateTime, returns an ISO date-time string like 2018-09-05 23:05:19.123Z (with a space instead of T)

format->LocalDate-compact clj

(format->LocalDate-compact inst)

Inputs: [inst :- Temporal] Returns: s/Str

Given an Instant or ZonedDateTime, returns a compact date-time string like 2018-09-05 23:05:19.123Z => 20180905

format->LocalDate-iso clj

(format->LocalDate-iso zdt)

Inputs: [zdt :- Temporal] Returns: s/Str

Given an Instant or ZonedDateTime, returns a string like 2018-09-05

format->timestamp-compact clj

(format->timestamp-compact inst)

Inputs: [inst :- Temporal] Returns: s/Str

Given an Instant or ZonedDateTime, returns a compact date-time string like 2018-09-05 23:05:19.123Z => 20180905-230519

Instant? clj

(Instant? it)

Returns true iff arg is an instance of java.time.Instant

joda-instant? clj

(joda-instant? it)

Returns true iff arg is an instance of org.joda.time.ReadableInstant

LocalDate->Date clj

(LocalDate->Date ld)

Inputs: [ld :- LocalDate] Returns: Date

Converts a LocalDate to a java.util.Date, using midnight (start of day) and the UTC timezone.

LocalDate->Instant clj

(LocalDate->Instant ld)

Inputs: [ld :- LocalDate] Returns: Instant

Converts a LocalDate to a java.util.Date, using midnight (start of day) and the UTC timezone.

LocalDate->tagval clj

(LocalDate->tagval ld)

Inputs: [ld :- LocalDate] Returns: {:LocalDate s/Str}

Converts a java.time.LocalDate object to a tagval

LocalDate-interval->days clj

(LocalDate-interval->days interval)

Inputs: [interval :- Interval] Returns: s/Int

Returns the duration in days from the start to the end of a LocalDate Interval

LocalDate? clj

(LocalDate? arg)

Inputs: [arg] Returns: s/Bool

Returns true iff arg is of type LocalDate

localdates->day-idxs clj

(localdates->day-idxs ld-vals)

Inputs: [ld-vals :- [LocalDate]] Returns: [s/Int]

Converts a sequence of LocalDate objects into an integer series like [0 1 2 ...], relative to the first value. Assumes LocalDate's are in ascending order.

LocalDateStr? clj

(LocalDateStr? arg)

Inputs: [arg] Returns: s/Bool

Returns true iff string is a legal ISO LocalDate like '1999-12-31' (valid for years 1900-2100).

millis->Instant clj

(millis->Instant millis)

Wrapper for java.time.Instant/ofEpochMilli

now->Instant clj

(now->Instant)

Returns the current time as a java.lang.Instant

now->iso-str clj

(now->iso-str)

Returns an ISO string representation of the current time, like '2019-02-19T18:44:01.123456Z'

now->iso-str-simple clj

(now->iso-str-simple)

Returns a canonical string representation of the current time truncated to the current second, like '2019-02-19 18:44:01Z'

now->ZonedDateTime clj

(now->ZonedDateTime)

Returns the current time as a java.lang.ZonedDateTime (UTC)

parse-iso-str->Instant clj

(parse-iso-str->Instant iso-datetime-str)

Inputs: [iso-datetime-str :- s/Str] Returns: Instant

Convert an ISO 8601 string to epoch milliseconds. Will collapse excess whitespace.

parse-iso-str->millis clj

(parse-iso-str->millis iso-datetime-str)

Inputs: [iso-datetime-str :- s/Str] Returns: s/Int

Convert an ISO 8601 string to epoch milliseconds. Will collapse excess whitespace.

parse-iso-str->sql-timestamp clj

(parse-iso-str->sql-timestamp iso-datetime-str)

Inputs: [iso-datetime-str :- s/Str]

Convert an ISO 8601 string to a java.sql.Timestamp

parse-iso-str-nice->Instant clj

(parse-iso-str-nice->Instant iso-str)

Inputs: [iso-str :- s/Str] Returns: Instant

Parse a near-iso string like '2019-09-19 18:09:35Z' (it is missing the 'T' between the date & time fields) into an Instant. Will collapse excess whitespace.

parse-sql-timestamp-str->Instant-utc clj

(parse-sql-timestamp-str->Instant-utc sql-timestamp-str)

Inputs: [sql-timestamp-str :- s/Str] Returns: Instant

Parse a near-Timestamp string like ' 2019-09-19 18:09:35 ' (sloppy spacing) into an Instant. Assumes UTC timezone. Will collapse excess whitespace.

Period? clj

(Period? it)

Returns true iff arg is an instance of org.joda.time.ReadablePeriod. Example: (period (days 3)) => true

previous-or-same clj

(previous-or-same temporal tgt-dow)

Inputs: [temporal :- Temporal tgt-dow :- DayOfWeek] Returns: Temporal

Given a temporal value and a target such as DayOfWeek/SUNDAY, makes the minimal change to previous or same day of week. Example:

  (previous-or-same t DayOfWeek/SUNDAY)

pseudo-Temporal clj

range clj

(range start-inst stop-inst step-dur)

Inputs: [start-inst :- Temporal stop-inst :- Temporal step-dur :- TemporalAmount] Returns: [Temporal]

Returns a vector of instants in the half-open interval [start stop) (both instants) with increment <step> (a period). Not lazy. Example:

 (range (zoned-date-time 2018 9 1)
        (zoned-date-time 2018 9 5)
        (Duration/ofDays 1)))  => <vector of 4 ZonedDateTime's from 2018-9-1 thru 2018-9-4>

same-instant? clj

(same-instant? & temporals)

Inputs: [& temporals :- [pseudo-Temporal]] Returns: s/Bool

Returns true iff two Instant/ZonedDateTime objects (or similar) represent the same instant of time, regardless of time zone. A thin wrapper over ZonedDateTime/isEqual

stringify-times clj

(stringify-times form)

Will recursively walk any data structure, converting any fixed-time-point? object to a string

tagval->LocalDate clj

(tagval->LocalDate ldtv)

Inputs: [ldtv :- {:LocalDate s/Str}] Returns: LocalDate

Parses a tagval into a java.time.LocalDate

Temporal? clj

(Temporal? it)

Returns true iff arg is an instance of java.time.temporal.Temporal

truncated-to clj

(truncated-to temporal chrono-unit)

Inputs: [temporal :- Temporal chrono-unit :- ChronoUnit]

Returns a Temporal truncated to corresponding ChronoUnit. Example:

  (truncated-to t ChronoUnit/HOURS)

walk-Instant->sql-Timestamp clj

(walk-Instant->sql-Timestamp tree)

Walks a tree-like data structure, converting any instances of java.sql.Timestamp => java.time.Instant

walk-Instant->str clj

(walk-Instant->str tree)

Walks a tree-like data structure, calling .toString on any instances java.time.Instant

walk-LocalDate->tagval clj

(walk-LocalDate->tagval data)

walk-sql-Timestamp->Instant clj

(walk-sql-Timestamp->Instant tree)

Walks a tree-like data structure, converting any instances of java.sql.Timestamp => java.time.Instant

with-zoneid clj macro

(with-zoneid zone-id & forms)

year-quarter? clj

(year-quarter? arg)

Inputs: [arg] Returns: s/Bool

Returns true iff arg is indicates a (financial) quarter in the year.

year-quarters clj

zoned-date-time clj

(zoned-date-time)

(zoned-date-time year)

(zoned-date-time year month)

(zoned-date-time year month day)

(zoned-date-time year month day hour)

(zoned-date-time year month day hour minute)

(zoned-date-time year month day hour minute second)

(zoned-date-time year month day hour minute second nanos)

(zoned-date-time year month day hour minute second nanos zone-id)

Returns a java.time.ZonedDateTime with the specified parameters and truncated values (day/month=1, hour/minute/sec=0) for all other date/time components. Assumes time zone is UTC unless the maximum-arity constructor is used. Usage:

; Assumes UTC time zone (zoned-date-time) => current time (zoned-date-time year) (zoned-date-time year month) (zoned-date-time year month day) (zoned-date-time year month day hour) (zoned-date-time year month day hour minute) (zoned-date-time year month day hour minute second) (zoned-date-time year month day hour minute second nanos)

; Explicit time zone (zoned-date-time year month day hour minute second nanos zone-id)

; Explicit time zone alternate shortcut arities. (with-zoneid zoneid-us-eastern (zoned-date-time year month day ...)) ; any arity w/o zone-id

ZonedDateTime? clj

(ZonedDateTime? it)

Returns true iff arg is an instance of java.time.ZonedDateTime

zoneid-us-alaska clj

zoneid-us-aleutian clj

zoneid-us-central clj

zoneid-us-eastern clj

zoneid-us-hawaii clj

zoneid-us-mountain clj

zoneid-us-pacific clj

zoneid-utc clj