package timere

You can search for identifiers within the package.

in-package search v0.2.0

package timere

timere
- CHANGELOG
- README
- Library timere
  - Timere
    
    Duration
    
    Time_zone
    
    Raw
    
    Sexp
    
    JSON
    
    Db
    
    Raw
    
    Sexp
    
    Date_time
    
    Utils
- Library timere.tzdb
  - Timere_tzdb
    
    M
- Library timere.tzlocal
  - Timere_tzlocal
- Library timere_tzdb_full
  - Timere_tzdb
    
    M
- Library timere_tzdb_none
  - Timere_tzdb
    
    M
- Library timere_tzlocal_none
  - Timere_tzlocal
- Library timere_tzlocal_unix
  - Timere_tzlocal
- Sources
  - timere
    
    ISO8601.ml
    
    RFC3339.ml
    
    bigarray_utils.ml
    
    constants.ml
    
    date_time_components.ml
    
    duration.ml
    
    infix.ml
    
    int64_set.ml
    
    int64_utils.ml
    
    int_set.ml
    
    misc_utils.ml
    
    of_sexp.ml
    
    of_sexp_utils.ml
    
    parser_components.ml
    
    pattern.ml
    
    pattern_resolver.ml
    
    points.ml
    
    printers.ml
    
    ptime_utils.ml
    
    resolver.ml
    
    seq_utils.ml
    
    string_map.ml
    
    time.ml
    
    time_ast.ml
    
    time_zone.ml
    
    time_zone_constants.ml
    
    timere.ml
    
    timere__.ml
    
    to_sexp.ml
    
    to_sexp_utils.ml
  - timere_tzdb_full
    
    timere_tzdb.ml
    
    timere_tzdb__timere_tzdb_full__.ml
    
    tzdb_marshalled.ml
  - timere_tzdb_none
    
    timere_tzdb.ml
    
    timere_tzdb__timere_tzdb_none__.ml
  - timere_tzlocal_none
    
    timere_tzlocal.ml
    
    timere_tzlocal__timere_tzlocal_none__.ml
  - timere_tzlocal_unix
    
    timere_tzlocal.ml
    
    timere_tzlocal__timere_tzlocal_unix__.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Timere.Date_time`Source

Sourcetype tz_info = private [

| `Tz_only of Time_zone.t
| `Tz_offset_s_only of int
| `Tz_and_tz_offset_s of Time_zone.t * int

]

Sourcetype t = private {

year : int;
month : month;
day : int;
hour : int;
minute : int;
second : int;
tz_info : tz_info;

}

Source

val make : 
  ?tz:Time_zone.t ->
  year:int ->
  month:month ->
  day:int ->
  hour:int ->
  minute:int ->
  second:int ->
  t option

Constructs a date time providing only a time zone (defaults to local time zone).

A precise offset is inferred if possible.

Note that this may yield a ambiguous date time if the time zone has varying offsets, e.g. DST.

See make_precise for the most precise construction.

Source

val make_exn : 
  ?tz:Time_zone.t ->
  year:int ->
  month:month ->
  day:int ->
  hour:int ->
  minute:int ->
  second:int ->
  t

raises Invalid_argument
if make fails

Source

val make_precise : 
  ?tz:Time_zone.t ->
  year:int ->
  month:month ->
  day:int ->
  hour:int ->
  minute:int ->
  second:int ->
  tz_offset_s:tz_offset_s ->
  unit ->
  t option

Constructs a date time providing time zone offset in seconds, and optionally a time zone.

If a time zone is provided, then the offset is checked against the time zone record to make sure the time zone does use said offset for the particular date time.

Source

val make_precise_exn : 
  ?tz:Time_zone.t ->
  year:int ->
  month:month ->
  day:int ->
  hour:int ->
  minute:int ->
  second:int ->
  tz_offset_s:tz_offset_s ->
  unit ->
  t

raises Invalid_argument
if make_precise fails

Sourcetype 'a local_result = [

| `Single of 'a
| `Ambiguous of 'a * 'a

]

Result for when a local date time may be involved, e.g. using a date time with no precise time zone offset attached.

`Single is yielded when the date time maps to exactly one 'a. This happens when date time carries an accurate offset, or when the date time is not affected by any offset shifts (thus an accurate offset can be inferred).
`Ambiguous is yielded when date time maps to more than one (exactly two) 'a. This happens when DST ends and "goes back an hour" for instance.

Sourceval to_timestamp : t -> timestamp local_result

Sourceval to_timestamp_single : t -> timestamp

raises Invalid_argument
if to_timestamp does not yield a `Single result

Sourceval min_of_timestamp_local_result : timestamp local_result -> timestamp

Sourceval max_of_timestamp_local_result : timestamp local_result -> timestamp

Sourceval of_timestamp : ?tz_of_date_time:Time_zone.t -> timestamp -> t option

Sourceval equal : t -> t -> bool

Sourceval min : t

Sourceval max : t

Sourceval now : ?tz_of_date_time:Time_zone.t -> unit -> t

Sourceval to_string : ?format:string -> t -> string

Pretty printing for date time.

Default format string:

{year} {mon:Xxx} {mday:0X} {hour:0X}:{min:0X}:{sec:0X} \
{tzoff-sign}{tzoff-hour:0X}:{tzoff-min:0X}:{tzoff-sec:0X}

Format string specification:

{{               literal {
{year}           year
{mon:Xxx}        abbreviated month name (e.g. Jan), casing of 'x' controls the casing
{mon:Xx*}        full month name (e.g. January), casing of first 'x' controls casing of first letter,
                 casing of second 'x' controls casing of following letters
{mday:cX}        month day (e.g.  1) character 'c' before 'X' is used for padding
                 (leave out character for no padding)
{wday:Xxx}       abbreviated weekday name (e.g. Sun), the casing of 'x' controls the casing
{wday:Xx*}       full weekday name (e.g. Sunday), casing of first 'x' controls casing of first letter,
                 casing of second 'x' controls casing of following letters
{hour:cX}        hour in 24-hour format, character 'c' before 'X' determines padding
                 (leave out character for no padding)
{12hour:cX}      hour in 12-hour format, character 'c' before 'X' determines padding
                 (leave out character for no padding)
{min:cX}         minute, character 'c' before 'X' determines padding
                 (leave out character for no padding)
{sec:cX}         second, character 'c' before 'X' determines padding
                 (leave out character for no padding)
{tzoff-sign}     time zone offset sign ('+' or '-')
                 yields "N/A" if time zone offset is not available
{tzoff-hour:cX}  time zone offset hour, follows same padding rule as "{hour:cX}"
                 yields "N/A" if time zone offset is not available
{tzoff-min:cX}   time zone offset minute, follows same padding rule as "{min:cX}"
                 yields "N/A" if time zone offset is not available
{tzoff-sec:cX}   time zone offset second, follows same padding rule as "{sec:cX}"
                 yields "N/A" if time zone offset is not available

Sourceval pp : ?format:string -> unit -> Format.formatter -> t -> unit

Sourceval to_rfc3339 : t -> string

Sourceval of_iso8601 : string -> (t, string) result

Sourceval to_sexp : t -> CCSexp.t

Sourceval to_sexp_string : t -> string

Sourceval of_sexp : CCSexp.t -> (t, string) result

Sourceval of_sexp_string : string -> (t, string) result

Sourceval pp_sexp : Format.formatter -> t -> unit

package timere

Module Timere.Date_timeSource

Module `Timere.Date_time`Source