Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Synopsis
- data UnixTime = UnixTime {
- utSeconds :: !CTime
- utMicroSeconds :: !Int32
- getUnixTime :: IO UnixTime
- parseUnixTime :: Format -> ByteString -> UnixTime
- parseUnixTimeGMT :: Format -> ByteString -> UnixTime
- formatUnixTime :: Format -> UnixTime -> IO ByteString
- formatUnixTimeGMT :: Format -> UnixTime -> ByteString
- type Format = ByteString
- webDateFormat :: Format
- mailDateFormat :: Format
- data UnixDiffTime = UnixDiffTime {
- udtSeconds :: !CTime
- udtMicroSeconds :: !Int32
- diffUnixTime :: UnixTime -> UnixTime -> UnixDiffTime
- addUnixDiffTime :: UnixTime -> UnixDiffTime -> UnixTime
- secondsToUnixDiffTime :: Integral a => a -> UnixDiffTime
- microSecondsToUnixDiffTime :: Integral a => a -> UnixDiffTime
- fromEpochTime :: EpochTime -> UnixTime
- toEpochTime :: UnixTime -> EpochTime
- fromClockTime :: ClockTime -> UnixTime
- toClockTime :: UnixTime -> ClockTime
Data structure
Data structure for Unix time.
Please note that this uses GHC-derived Eq
and Ord
instances.
Notably
>>>
UnixTime 1 0 > UnixTime 0 999999999
True
You should instead use UnixDiffTime
along with its helpers such
as microSecondsToUnixDiffTime
which will ensure
that such unusual values are never created.
UnixTime | |
|
Instances
Storable UnixTime Source # | |
Defined in Data.UnixTime.Types | |
Generic UnixTime Source # | |
Show UnixTime Source # | |
Binary UnixTime Source # | |
Eq UnixTime Source # | |
Ord UnixTime Source # | |
Defined in Data.UnixTime.Types | |
type Rep UnixTime Source # | |
Defined in Data.UnixTime.Types type Rep UnixTime = D1 ('MetaData "UnixTime" "Data.UnixTime.Types" "unix-time-0.4.12-7VXgHv9t2uw6t3Fm5XpK39" 'False) (C1 ('MetaCons "UnixTime" 'PrefixI 'True) (S1 ('MetaSel ('Just "utSeconds") 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 CTime) :*: S1 ('MetaSel ('Just "utMicroSeconds") 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 Int32))) |
Getting time
Parsing and formatting time
parseUnixTime :: Format -> ByteString -> UnixTime Source #
Parsing ByteString
to UnixTime
interpreting as localtime.
This is a wrapper for strptime_l().
Many implementations of strptime_l() do not support %Z and
some implementations of strptime_l() do not support %z, either.
utMicroSeconds
is always set to 0.
parseUnixTimeGMT :: Format -> ByteString -> UnixTime Source #
Parsing ByteString
to UnixTime
interpreting as GMT.
This is a wrapper for strptime_l().
utMicroSeconds
is always set to 0.
>>>
parseUnixTimeGMT webDateFormat "Thu, 01 Jan 1970 00:00:00 GMT"
UnixTime {utSeconds = 0, utMicroSeconds = 0}
formatUnixTime :: Format -> UnixTime -> IO ByteString Source #
Formatting UnixTime
to ByteString
in local time.
This is a wrapper for strftime_l().
utMicroSeconds
is ignored.
The result depends on the TZ environment variable.
formatUnixTimeGMT :: Format -> UnixTime -> ByteString Source #
Formatting UnixTime
to ByteString
in GMT.
This is a wrapper for strftime_l().
utMicroSeconds
is ignored.
>>>
formatUnixTimeGMT webDateFormat $ UnixTime 0 0
"Thu, 01 Jan 1970 00:00:00 GMT">>>
let ut = UnixTime 100 200
>>>
let str = formatUnixTimeGMT "%s" ut
>>>
let ut' = parseUnixTimeGMT "%s" str
>>>
((==) `on` utSeconds) ut ut'
True>>>
((==) `on` utMicroSeconds) ut ut'
False
Format
type Format = ByteString Source #
Format of the strptime()/strftime() style.
webDateFormat :: Format Source #
Format for web (RFC 2616).
The value is "%a, %d %b %Y %H:%M:%S GMT".
This should be used with formatUnixTimeGMT
and parseUnixTimeGMT
.
mailDateFormat :: Format Source #
Format for e-mail (RFC 5322).
The value is "%a, %d %b %Y %H:%M:%S %z".
This should be used with formatUnixTime
and parseUnixTime
.
Difference time
data UnixDiffTime Source #
Data structure for UnixTime diff.
It is up to the user to ensure that
.
Helpers such as udtMicroSeconds
< 1000000microSecondsToUnixDiffTime
can help
you to create valid values. For example, it's a mistake to use
addUnixDiffTime
with a value UnixDiffTime 0 9999999
as it will produce an incorrect value back. You should instead use
functions such as microSecondsToUnixDiffTime
to
create values that are in-range. This avoids any gotchas when then
doing comparisons.
UnixDiffTime | |
|
Instances
diffUnixTime :: UnixTime -> UnixTime -> UnixDiffTime Source #
Calculating difference between two UnixTime
.
>>>
UnixTime 100 2000 `diffUnixTime` UnixTime 98 2100
UnixDiffTime {udtSeconds = 1, udtMicroSeconds = 999900}
addUnixDiffTime :: UnixTime -> UnixDiffTime -> UnixTime Source #
Adding difference to UnixTime
.
>>>
UnixTime 100 2000 `addUnixDiffTime` microSecondsToUnixDiffTime ((-1003000) :: Int)
UnixTime {utSeconds = 98, utMicroSeconds = 999000}
secondsToUnixDiffTime :: Integral a => a -> UnixDiffTime Source #
Creating difference from seconds.
>>>
secondsToUnixDiffTime (100 :: Int)
UnixDiffTime {udtSeconds = 100, udtMicroSeconds = 0}
microSecondsToUnixDiffTime :: Integral a => a -> UnixDiffTime Source #
Creating difference from micro seconds.
>>>
microSecondsToUnixDiffTime (12345678 :: Int)
UnixDiffTime {udtSeconds = 12, udtMicroSeconds = 345678}
>>>
microSecondsToUnixDiffTime ((-12345678) :: Int)
UnixDiffTime {udtSeconds = -12, udtMicroSeconds = -345678}
Translating time
fromEpochTime :: EpochTime -> UnixTime Source #
From EpochTime
to UnixTime
setting utMicroSeconds
to 0.
toEpochTime :: UnixTime -> EpochTime Source #
From UnixTime
to EpochTime
ignoring utMicroSeconds
.