java-time — clojure.java-time 0.3.3

abs clj

(abs a)

Returns the absolute value of a temporal amount:

(abs (negate x)) == (abs x)

abuts? clj

(abuts? i oi)

True if this interval abut with the other one

adjust clj

(adjust entity adjuster & args)

Adjusts the temporal entity using the provided adjuster with optional args.

The adjuster should either be a keyword which resolves to one of the predefined adjusters (see java-time.repl/show-adjusters) an instance of TemporalAdjuster or a function which returns another temporal entity when applied to the given one:

(adjust (local-date 2015 1 1) :next-working-day) => #<LocalDate 2015-1-2>

(adjust (local-date 2015 1 1) :first-in-month :monday) => #<LocalDate 2015-1-5>

(adjust (local-date 2015 1 1) plus (days 1)) => #<LocalDate 2015-1-2>

advance-clock! clj

(advance-clock! clock amount)

Advances the clock by the given time amount.

This mutates the mock clock.

after? clj

(after? x)

(after? x y)

(after? x y & more)

Returns a truthy value if time entities are ordered from the latest to the earliest (same semantics as >):

(after? (local-date 2011) (local-date 2010) (local-date 2009)) => truthy...

(after? (instant 99999999) (interval (instant 10000) (instant 1000000))) => truthy...

am-pm clj

(am-pm)

(am-pm v__3848__auto__)

(am-pm fmt__3849__auto__ arg__3850__auto__)

Returns the AmPm for the given keyword name (:am or :pm), ordinal or entity. Current AM/PM if no arguments given.

am-pm? clj

(am-pm? o__3847__auto__)

as clj

(as o k)

(as o k1 k2)

(as o k1 k2 & ks)

Values of property/unit identified by keys/objects ks of the temporal entity o, e.g.

(as (duration 1 :hour) :minutes) => 60

(as (local-date 2015 9) :year :month-of-year) => [2015 9]

as-map clj

(as-map e)

(as-map e value-fn)

Converts a time entity to a map of property key -> value as defined by the passed in value-fn. By default the actual value of the unit/field is produced.

(as-map (duration)) => {:nanos 0, :seconds 0}

(as-map (local-date 2015 1 1)) => {:year 2015, :month-of-year 1, :day-of-month 1, ...}

available-zone-ids clj

(available-zone-ids)

Returns a set of string identifiers for all available ZoneIds.

before? clj

(before? x)

(before? x y)

(before? x y & more)

Returns a truthy value if time entities are ordered from the earliest to the latest (same semantics as <):

(before? (local-date 2009) (local-date 2010) (local-date 2011)) => truthy...

(before? (interval (instant 10000) (instant 1000000)) (instant 99999999)) => truthy...

chronology clj

(chronology o)

The Chronology of the entity

clock? clj

(clock? x)

Returns true if x is an instance of java.time.Clock.

contains? clj

(contains? i o)

True if the interval contains the given instant or interval

convert-amount clj

(convert-amount amount from-unit to-unit)

Converts an amount from one unit to another. Returns a map of:

• :whole - the whole part of the conversion in the to unit
• :remainder - the remainder in the from unit

Arguments may be keywords or instances of TemporalUnit.

Converts between precise units - nanos up to weeks, treating days as exact multiples of 24 hours. Also converts between imprecise units - months up to millenia. See ChronoUnit and IsoFields for all of the supported units. Does not convert between precise and imprecise units.

Throws ArithmeticException if long overflow occurs during computation.

(convert-amount 10000 :seconds :hours) => {:remainder 2800 :whole 2}

day-of-month clj

(day-of-month)

(day-of-month G__4056)

(day-of-month fmt__3881__auto__ arg__3882__auto__)

Returns the DayOfMonth for the given entity, clock, zone or day of month. Current day of month if no arguments given.

day-of-month? clj

(day-of-month? o__3880__auto__)

day-of-week clj

(day-of-week)

(day-of-week v__3848__auto__)

(day-of-week fmt__3849__auto__ arg__3850__auto__)

Returns the DayOfWeek for the given day keyword name (e.g. :monday), ordinal or entity. Current day if no arguments given.

day-of-week? clj

(day-of-week? o__3847__auto__)

day-of-year clj

(day-of-year)

(day-of-year G__4067)

(day-of-year fmt__3881__auto__ arg__3882__auto__)

Returns the DayOfYear for the given entity, clock, zone or day of year. Current day of year if no arguments given.

day-of-year? clj

(day-of-year? o__3880__auto__)

days clj

(days v__3320__auto__)

duration clj

(duration)

(duration arg_1_3276)

(duration arg_1_3277 arg_2_3278)

Creates a duration - a temporal entity representing standard days, hours, minutes, millis, micros and nanos. The duration itself contains only seconds and nanos as properties.

Given one argument will

• interpret as millis if a number
• try to parse from the standard format if a string
• extract supported units from another TemporalAmount
• convert from a Joda Period/Duration

Given two arguments will

• get a duration between two Temporals
• get a duration of a specified unit, e.g. (duration 100 :seconds)

duration? clj

(duration? v__2346__auto__)

True if an instance of Duration.

end clj

(end i)

Gets the end instant of the interval

field clj

(field k)

(field entity k)

Returns a TemporalField for the given key k or extracts the field from the given temporal entity.

You can see predefined fields via java-time.repl/show-fields.

If you want to make your own custom TemporalFields resolvable, you need to rebind the java-time.properties/*fields* to a custom java-time.properties.FieldGroup.

field? clj

(field? o)

True if this is a TemporalField.

fields clj

(fields o)

Fields present in this temporal entity

fixed-clock clj

(fixed-clock)

(fixed-clock i)

(fixed-clock i z)

Creates a fixed clock either at the current instant or at the supplied instant/instant + zone.

format clj

(format o)

(format fmt o)

Formats the given time entity as a string.

Accepts something that can be converted to a DateTimeFormatter or a formatter key, e.g. :iso-offset-time, as a first argument. Given one argument uses the default format.

(format (zoned-date-time)) "2015-03-21T09:22:46.677800+01:00[Europe/London]"

(format :iso-date (zoned-date-time)) "2015-03-21+01:00"

formatter clj

(formatter fmt)

(formatter fmt {:keys [resolver-style case] :or {case :sensitive}})

Constructs a DateTimeFormatter out of a

• format string - "yyyy/MM/dd", "HH:mm", etc.
• formatter name - :iso-date, :iso-time, etc.

Accepts a map of options as an optional second argument:

• resolver-style - either :strict, :smartor :lenient
• case - either :insensitive or :sensitive (defaults to :sensitive)

friday? clj

(friday? o__4612__auto__)

Returns true if the given time entity with the day-of-week property falls on a friday.

gap clj

(gap i oi)

Gets the gap between this interval and the other one or nil

hours clj

(hours v__3302__auto__)

Duration of a specified number of hours.

instant clj

(instant)

(instant arg_1_2872)

(instant arg_1_2873 arg_2_2874)

Creates an Instant. The following arguments are supported:

• no arguments - current instant
• one argument
  • clock
  • java.util.Date/Calendar
  • another temporal entity
  • string representation
  • millis from epoch
• two arguments
  • formatter (format) and a string

instant->sql-timestamp clj

(instant->sql-timestamp instant-or-millis)

Creates a java.sql.Timestamp from the provided instant-or-millis - a millisecond numeric time value or something convertible to an Instant.

Please consider using the JSR-310 Java Time types instead of java.sql.Timestamp if your drivers support them.

java.sql.Timestamp is a version of a java.util.Date supposed to be used as a local date-time (no timezone) for the purposes of conversion from/to native JDBC driver TIMESTAMP types.

instant? clj

(instant? v__2346__auto__)

True if an instance of Instant.

interval clj

(interval o)

(interval a b)

Constructs an interval out of a string, start and end instants or a start

• duration:

(j/interval "2010-01-01T00:00:00Z/2013-01-01T00:00:00Z") => #<Interval 2010-01-01T00:00:00Z/2013-01-01T00:00:00Z>

(j/interval (j/instant 100000) (j/instant 1000000)) => #<Interval 1970-01-01T00:01:40Z/1970-01-01T00:16:40Z>

(j/interval (j/instant 100000) (j/duration 15 :minutes)) => #<Interval 1970-01-01T00:01:40Z/1970-01-01T00:16:40Z>

Requires the optional threeten-extra dependency.

interval? clj

(interval? o)

True if Interval

iterate clj

(iterate f initial v & vs)

Returns a lazy sequence of initial , (apply f initial v vs), etc.

Useful when you want to produce a sequence of temporal entities, for example:

(iterate plus (days 0) 1) => (#<Period P0D> #<Period P1D> #<Period P2D> ...)

(iterate plus (local-date 2010 1 1) (years 1)) => (#<LocalDate 2010-01-01> #<LocalDate 2011-01-01> ...)

(iterate adjust (local-date 2010 1 1) :next-working-day) => (#<LocalDate 2010-01-01> #<LocalDate 2010-01-04> ...)

java-date clj

(java-date)

(java-date a)

(java-date a b)

Creates a java.util.Date out of any combination of arguments valid for java-time/instant or the Instant itself.

A java.util.Date represents an instant in time. It's a direct analog of the java.time.Instant type introduced in the JSR-310. Please consider using the java.time.Instant (through java-time/instant) directly.

largest-min-value clj

(largest-min-value p)

Largest minimum value of this property

leap? clj

(leap? o)

True if the year of this entity is a leap year.

local-date clj

(local-date)

(local-date arg_1_2911)

(local-date arg_1_2912 arg_2_2913)

(local-date arg_1_2914 arg_2_2915 arg_3_2916)

Creates a LocalDate. The following arguments are supported:

• no arguments - current local-date
• one argument
  • clock
  • another temporal entity
  • string representation
  • year
• two arguments
  • formatter (format) and a string
  • an instant and a zone id
  • another temporal entity and an offset (preserves local time)
  • year and month
• three arguments
  • year, month and date

local-date-time clj

(local-date-time)

(local-date-time arg_1_2991)

(local-date-time arg_1_2992 arg_2_2993)

(local-date-time arg_1_2994 arg_2_2995 arg_3_2996)

(local-date-time y m d h)

(local-date-time y m d h mm)

(local-date-time y m d h mm ss)

(local-date-time y m d h mm ss n)

Creates a LocalDateTime. The following arguments are supported:

• no arguments - current local date-time
• one argument
  • clock
  • another temporal entity
  • string representation
  • year
• two arguments
  • local date and local time
  • an instant and a zone id
  • formatter (format) and a string
  • year and month

three and more arguments - year/month/day/...

local-date-time? clj

(local-date-time? v__2346__auto__)

True if an instance of LocalDateTime.

local-date? clj

(local-date? v__2346__auto__)

True if an instance of LocalDate.

local-time clj

(local-time)

(local-time arg_1_2951)

(local-time arg_1_2952 arg_2_2953)

(local-time arg_1_2954 arg_2_2955 arg_3_2956)

(local-time h m s nn)

Creates a LocalTime. The following arguments are supported:

• no arguments - current local time
• one argument
  • clock
  • another temporal entity
  • string representation
  • hours
• two arguments
  • formatter (format) and a string
  • an instant and a zone id
  • hours and minutes
• three/four arguments - hour, minute, second, nanos

local-time? clj

(local-time? v__2346__auto__)

True if an instance of LocalTime.

max clj

(max o & os)

Latest/longest of the given time entities. Entities should be of the same type

max-value clj

(max-value p)

Maximum value of this property, e.g. 29th of February for months

micros clj

(micros micros)

Duration of a specified number of microseconds.

millis clj

(millis v__3302__auto__)

Duration of a specified number of millis.

min clj

(min o & os)

Earliest/shortest of the given time entities. Entities should be of the same type

min-value clj

(min-value p)

Minimum value of this property

minus clj

(minus o & os)

Subtracts all of the os from the time entity o

(j/minus (j/local-date 2015) (j/years 1)) => <java.time.LocalDate "2014-01-01">

minutes clj

(minutes v__3302__auto__)

Duration of a specified number of minutes.

mock-clock clj

(mock-clock)

(mock-clock instant)

(mock-clock instant zone)

Returns a mock implementation of the java.time.Clock. The mock supports advance-clock! operation which allows to move the time in the clock, e.g.:

(let [clock (mock-clock 0 "UTC")] (with-clock clock (is (= (value clock) 0)) (is (= (instant) (instant 0))) (advance-clock! clock (j/millis 1)) (is (= (value clock) 1)) (is (= (instant) (instant 1)))))

You can move the clock back via advancing by a negative temporal amount.

Creates a clock at epoch in the default timezone when called without arguments.

monday? clj

(monday? o__4612__auto__)

Returns true if the given time entity with the day-of-week property falls on a monday.

month clj

(month)

(month v__3848__auto__)

(month fmt__3849__auto__ arg__3850__auto__)

Returns the Month for the given month keyword name (e.g. :january), ordinal or entity. Current month if no arguments given.

month-day clj

(month-day)

(month-day G__3974)

(month-day a__3894__auto__ b__3895__auto__)

Returns the MonthDay for the given entity, string, clock, zone or month/day combination. Current month-day if no arguments given.

month-day? clj

(month-day? o__3891__auto__)

month? clj

(month? o__3847__auto__)

months clj

(months v__3320__auto__)

move-end-by clj

(move-end-by i & os)

Moves the end instant of the interval by the sum of given periods/durations/numbers of milliseconds.

(move-start-by (interval 0 10000) (millis 1000) (seconds 1)) => #<Interval ...:00Z/...:12Z>

Fails if the new end instant falls before the start instant.

(move-end-by (interval 0 10000) (millis -11000)) => DateTimeException...

move-end-to clj

(move-end-to i new-end)

Moves the end of the interval to the given instant (or something convertible to an instant):

(move-end-to (interval 0 10000) (instant 15000)) => #<Interval ...:00Z/...:15Z>

Fails if the new end instant falls before the start instant:

(move-end-to (interval 0 10000) (millis -1)) => DateTimeException...

move-start-by clj

(move-start-by i & os)

Moves the start instant of the interval by the sum of given periods/durations/numbers of milliseconds:

(move-start-by (interval 0 10000) (millis 1000) (seconds 1)) => #<Interval ...:02Z/...:10Z>

Fails if the new start instant falls after the end instant.

(move-start-by (interval 0 10000) (millis 11000)) ; => DateTimeException...

move-start-to clj

(move-start-to i new-start)

Moves the start instant of the interval to the given instant (or something convertible to an instant):

(move-start-to (interval 0 10000) (instant 5000)) => #<Interval ...:05Z/...:10Z>

Fails if the new start instant falls after the end instant:

(move-start-to (interval 0 10000) (millis 15000)) => DateTimeException...

multiply-by clj

(multiply-by o v)

Entity o mutlitplied by the value v

nanos clj

(nanos v__3302__auto__)

Duration of a specified number of nanos.

negate clj

(negate a)

Negates a temporal amount:

(negate (negate x)) == x

negative? clj

(negative? a)

True if the amount is negative

not-after? clj

Similar to before?, but also returns truthy if the inputs are equal.

not-before? clj

Similar to after?, but also returns truthy if the inputs are equal.

offset-clock clj

(offset-clock d)

(offset-clock c d)

Creates a clock offset from the current/provided clock by a given duration.

offset-date-time clj

(offset-date-time)

(offset-date-time arg_1_3491)

(offset-date-time arg_1_3492 arg_2_3493)

(offset-date-time arg_1_3494 arg_2_3495 arg_3_3496)

(offset-date-time y m d h)

(offset-date-time y mo d h m)

(offset-date-time y mo d h m s)

(offset-date-time y mo d h m s n)

(offset-date-time y mo d h m s n o)

Creates an OffsetDateTime. The following arguments are supported:

• no arguments - current date-time with the default offset
• one argument
  • clock
  • zone offset
  • another temporal entity
  • string representation
  • year
• two arguments
  • formatter (format) and a string
  • local date-time and an offset
  • another temporal entity and an offset (preserves local time)
  • year and month
• three arguments
  • local date, local time and an offset
  • year, month and date
• four up to seven arguments - position date-time constructors
• eight arguments - time fields up to nanoseconds and a zone offset

If zone offset is not specified, default will be used. You can check the default offset by invoking (zone-offset).

offset-date-time? clj

(offset-date-time? v__2346__auto__)

True if an instance of OffsetDateTime.

offset-time clj

(offset-time)

(offset-time arg_1_3531)

(offset-time arg_1_3532 arg_2_3533)

(offset-time h m s)

(offset-time h m s n)

(offset-time h m s n o)

Creates an OffsetTime. The following arguments are supported:

• no arguments - current time with the default offset
• one argument
  • clock
  • zone id
  • another temporal entity
  • string representation
  • hour
• two arguments
  • formatter (format) and a string
  • local time and an offset
  • instant and an offset
  • hour and minutes
• three arguments - hours, minutes, seconds
• four arguments - hours, minutes, seconds, nanos
• five arguments - last is the offset

If zone offset is not specified, default will be used. You can check the default offset by invoking (zone-offset).

offset-time? clj

(offset-time? v__2346__auto__)

True if an instance of OffsetTime.

overlap clj

(overlap i oi)

Gets the overlap between this interval and the other one or nil

overlaps? clj

(overlaps? i oi)

True if this interval overlaps the other one

period clj

(period)

(period arg_1_3332)

(period arg_1_3333 arg_2_3334)

(period arg_1_3335 arg_2_3336 arg_3_3337)

Creates a period - a temporal entity consisting of years, months and days.

Given one argument will

• interpret as years if a number
• try to parse from the standard format if a string
• extract supported units from another TemporalAmount
• convert from a Joda Period

Given two arguments will

• get a period of a specified unit, e.g. (period 10 :months)
• get a period between two temporals by converting them to local dates
• get a period of a specified number of years and months

Given three arguments will create a year/month/day period.

period? clj

(period? v__2346__auto__)

True if an instance of Period.

plus clj

(plus o & os)

Adds all of the os to the time entity o. plus is not commutative, the first argument is always the entity which will accumulate the rest of the arguments.

(j/plus (j/local-date 2015) (j/years 1)) => <java.time.LocalDate "2016-01-01">

properties clj

(properties o)

Map of properties present in this temporal entity

property clj

(property o k)

Property of this temporal entity under key k

quarter clj

(quarter)

(quarter v__3848__auto__)

(quarter fmt__3849__auto__ arg__3850__auto__)

Returns the Quarter for the given quarter keyword name (e.g. :q1), ordinal or entity. Current quarter if no arguments given.

quarter? clj

(quarter? o__3847__auto__)

range clj

(range p)

Range of values for this property

saturday? clj

(saturday? o__4612__auto__)

Returns true if the given time entity with the day-of-week property falls on a saturday.

seconds clj

(seconds v__3302__auto__)

Duration of a specified number of seconds.

set-clock! clj

(set-clock! clock time)

Sets the clock to the given time.

This mutates the mock clock.

smallest-max-value clj

(smallest-max-value p)

Smallest maximum value of this property, e.g. 28th of February for months

sql-date clj

(sql-date)

(sql-date G__4492)

(sql-date G__4493 G__4494)

(sql-date G__4495 G__4496 G__4497)

Creates a java.sql.Date out of any combination of arguments valid for java-time/local-date or the LocalDate itself.

Please consider using the JSR-310 Java Time types instead of java.sql.Date if your drivers support them.

Even though java.sql.Date extends a java.util.Date, it's supposed to be used as a local date (no time component or timezone) for the purposes of conversion from/to native JDBC driver DATE types.

sql-time clj

(sql-time)

(sql-time G__4529)

(sql-time G__4530 G__4531)

(sql-time G__4532 G__4533 G__4534)

Creates a java.sql.Time out of any combination of arguments valid for java-time/local-time (except the nanos constructor) or the LocalTime itself.

Please consider using the JSR-310 Java Time types instead of java.sql.Time if your drivers support them.

Even though java.sql.Time extends a java.util.Date, it's supposed to be used as a local time (no date component or timezone) for the purposes of conversion from/to native JDBC driver TIME types.

sql-timestamp clj

(sql-timestamp)

(sql-timestamp G__4499)

(sql-timestamp G__4500 G__4501)

(sql-timestamp G__4502 G__4503 G__4504)

(sql-timestamp G__4505 G__4506 G__4507 G__4508)

(sql-timestamp G__4509 G__4510 G__4511 G__4512 G__4513)

(sql-timestamp G__4514 G__4515 G__4516 G__4517 G__4518 G__4519)

(sql-timestamp G__4520 G__4521 G__4522 G__4523 G__4524 G__4525 G__4526)

Creates a java.sql.Timestamp in the local timezone out of any combination of arguments valid for java-time/local-date-time or the LocalDateTime itself.

The sql-timestamp constructor function does not support Timestamp construction from an Instant or a long millis value. Please use instant->sql-timestamp for this purpose.

Please consider using the JSR-310 Java Time types instead of java.sql.Timestamp if your drivers support them.

java.sql.Timestamp is a version of a java.util.Date supposed to be used as a local date-time (no timezone) for the purposes of conversion from/to native JDBC driver TIMESTAMP types.

standard-days clj

(standard-days v__3302__auto__)

Duration of a specified number of days.

start clj

(start i)

Gets the start instant of the interval

sunday? clj

(sunday? o__4612__auto__)

Returns true if the given time entity with the day-of-week property falls on a sunday.

supports? clj

(supports? o p)

True if the o entity supports the p property

system-clock clj

(system-clock)

(system-clock k)

Creates a system clock. In the default timezone if called without arguments, otherwise accepts a Zone Id.

thursday? clj

(thursday? o__4612__auto__)

Returns true if the given time entity with the day-of-week property falls on a thursday.

tick-clock clj

(tick-clock d)

(tick-clock c d)

Creates a clock wrapping system/provided clock that only ticks as per specified duration.

time-between clj

(time-between o e u)

Time between temporal entities o and e in unit u.

(j/time-between (j/local-date 2015) (j/local-date 2016) :days) => 365

(j/time-between :days (j/local-date 2015) (j/local-date 2016)) => 365

to-java-date clj

(to-java-date o)

Converts a date entity to a java.util.Date.

Deprecated: This function only has a single arity and works for entities directly convertible to java.time.Instant. Please consider using java-date instead.

to-millis-from-epoch clj

(to-millis-from-epoch o)

Converts a date entity to a long representing the number of milliseconds from epoch.

to-sql-date clj

(to-sql-date o)

Converts a local date entity to a java.sql.Date.

Deprecated: This function only has a single arity and works for entities directly convertible to java.time.LocalDate. Please consider using sql-date instead.

to-sql-timestamp clj

(to-sql-timestamp o)

Converts a date entity to a java.sql.Timestamp.

Deprecated: This function only has a single arity and works for entities directly convertible to java.time.Instant. Please consider using sql-timestamp instead.

truncate-to clj

(truncate-to o u)

Truncates this entity to the specified time unit. Only works for units that divide into the length of standard day without remainder (up to :days).

tuesday? clj

(tuesday? o__4612__auto__)

Returns true if the given time entity with the day-of-week property falls on a tuesday.

unit clj

(unit k)

(unit entity k)

Returns a TemporalUnit for the given key k or extracts the field from the given temporal entity.

You can see predefined units via java-time.repl/show-units.

If you want to make your own custom TemporalUnits resolvable, you need to rebind the java-time.properties/*units* to a custom java-time.properties.UnitGroup.

unit? clj

(unit? o)

True if this is a TemporalUnit.

units clj

(units o)

Units present in this temporal entity.

value clj

(value p)

Value of the property

value-range clj

(value-range {:keys [min-smallest min-largest max-smallest max-largest]})

(value-range min max)

Creates a ValueRange given the min and max amounts or a map of :min-smallest, :max-smallest, :min-largest and :max-largest.

wednesday? clj

(wednesday? o__4612__auto__)

Returns true if the given time entity with the day-of-week property falls on a wednesday.

weekday? clj

(weekday? dt)

weekend? clj

(weekend? dt)

weeks clj

(weeks v__3320__auto__)

when-joda-time-loaded clj macro

(when-joda-time-loaded & body)

Execute the body when Joda-Time classes are found on the classpath.

Take care - when AOT-compiling code using this macro, the Joda-Time classes must be on the classpath at compile time!

with-clock clj macro

(with-clock c & forms)

Executes the given forms in the scope of the provided clock.

All the temporal entities that get created without parameters will inherit their values from the clock:

(with-clock (system-clock "Europe/London") (zone-id)) => #<java.time.ZoneRegion Europe/London>

with-clock-fn clj

(with-clock-fn c f)

Executes the given function in the scope of the provided clock. All the temporal entities that get created without parameters will inherit their values from the clock.

with-largest-min-value clj

(with-largest-min-value p)

Underlying temporal entity with the value set to the largest minimum available for this property

with-max-value clj

(with-max-value p)

Underlying temporal entity with the value set to the maximum available for this property

with-min-value clj

(with-min-value p)

Underlying temporal entity with the value set to the minimum available for this property

with-offset clj

(with-offset o offset)

Sets the offset to the specified value ensuring that the local time stays the same.

(offset-time 10 30 0 0 +2) => #<java.time.OffsetTime 10:30+02:00> (with-offset *1 +3) => #<java.time.OffsetTime 10:30+03:00>

with-offset-same-instant clj

(with-offset-same-instant o offset)

Sets the offset to the specified value ensuring that the result has the same instant, e.g.:

(offset-time 10 30 0 0 +2) => #<java.time.OffsetTime 10:30+02:00> (with-offset-same-instant *1 +3) => #<java.time.OffsetTime 11:30+03:00>

with-smallest-max-value clj

(with-smallest-max-value p)

Underlying temporal entity with the value set to the smallest maximum available for this property

with-value clj

(with-value p v)

Underlying temporal entity with the value of this property set to v

with-zone clj

(with-zone o z)

Returns this temporal entity with the specified ZoneId

with-zone-same-instant clj

(with-zone-same-instant zdt z)

Sets the zone to the specified value ensuring that the result has the same instant, e.g.:

(zoned-date-time 2015) => #<java.time.ZonedDateTime 2015-01-01T00:00+00:00[Europe/London]> (with-zone-same-instant *1 "America/New_York") => #<java.time.ZonedDateTime 2014-12-31T18:00-05:00[America/New_York]>

year clj

(year)

(year G__3963)

(year fmt__3881__auto__ arg__3882__auto__)

Returns the Year for the given entity, string, clock, zone or number. Current year if no arguments given.

year-month clj

(year-month)

(year-month G__3991)

(year-month a__3894__auto__ b__3895__auto__)

Returns the YearMonth for the given entity, string, clock, zone or month/day combination. Current year-month if no arguments given.

year-month? clj

(year-month? o__3891__auto__)

year-quarter clj

(year-quarter)

(year-quarter G__4079)

(year-quarter a__3894__auto__ b__3895__auto__)

Returns the YearQuarter for the given entity, clock, zone or year with quarter. Current year quarter if no arguments given.

year-quarter? clj

(year-quarter? o__3891__auto__)

year? clj

(year? o__3880__auto__)

years clj

(years v__3320__auto__)

zero? clj

(zero? a)

True if the amount is zero

zone-id clj

(zone-id)

(zone-id arg_1_3463)

(zone-id arg_1_3464 arg_2_3465)

Creates a ZoneId from a string identifier, java.util.TimeZone or extracts from another temporal entity.

Returns default system zone id if no arguments provided.

Given two arguments will use the second as the offset.

zone-id? clj

(zone-id? v__2346__auto__)

True if an instance of ZoneId.

zone-offset clj

(zone-offset)

(zone-offset o)

(zone-offset h m)

(zone-offset h m s)

Creates a ZoneOffset from a string identifier (e.g. "+01"), a number of hours/hours and minutes/hours, minutes and seconds or extracts from another temporal entity.

Returns default system zone offset if no arguments provided.

zoned-date-time clj

(zoned-date-time)

(zoned-date-time arg_1_3558)

(zoned-date-time arg_1_3559 arg_2_3560)

(zoned-date-time arg_1_3561 arg_2_3562 arg_3_3563)

(zoned-date-time y m d h)

(zoned-date-time y mo d h m)

(zoned-date-time y mo d h m s)

(zoned-date-time y mo d h m s n)

(zoned-date-time y mo d h m s n o)

Creates a ZonedDateTime. The following arguments are supported:

• no arguments - current date-time in the default zone
• one argument
  • clock
  • zone id
  • another temporal entity
  • string representation
  • year
• two arguments
  • formatter and a string
  • local date-time and a zone id
  • year and month
• three arguments
  • local date, local time and a zone id
  • year, month and day
• four to seven arguments - date-time fields
• eight arguments - last is the zone id

If zone id is not specified, default zone id will be used. You can check the default zone by invoking (zone-id).

zoned-date-time? clj

(zoned-date-time? v__2346__auto__)

True if an instance of ZonedDateTime.