{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
module Pact.Time.Internal
(
Micros
, Day
, NominalDiffTime(..)
, toMicroseconds
, fromMicroseconds
, toSeconds
, fromSeconds
, nominalDay
, UTCTime(..)
, getCurrentTime
, day
, dayTime
, fromDayAndDayTime
, toPosixTimestampMicros
, fromPosixTimestampMicros
, mjdEpoch
, posixEpoch
, ModifiedJulianDay(..)
, ModifiedJulianDate(..)
, toModifiedJulianDate
, fromModifiedJulianDate
, AffineSpace(..)
, VectorSpace(..)
) where
import Control.DeepSeq
import Data.AdditiveGroup
import Data.AffineSpace
import Data.Decimal
import Data.Serialize
import Data.VectorSpace
import GHC.Generics hiding (from)
import GHC.Int (Int64)
import Lens.Micro
import Pact.Time.System
type Micros = Int64
type Day = Int
newtype NominalDiffTime = NominalDiffTime { NominalDiffTime -> Int64
_microseconds :: Micros }
deriving (NominalDiffTime -> NominalDiffTime -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NominalDiffTime -> NominalDiffTime -> Bool
$c/= :: NominalDiffTime -> NominalDiffTime -> Bool
== :: NominalDiffTime -> NominalDiffTime -> Bool
$c== :: NominalDiffTime -> NominalDiffTime -> Bool
Eq, Eq NominalDiffTime
NominalDiffTime -> NominalDiffTime -> Bool
NominalDiffTime -> NominalDiffTime -> Ordering
NominalDiffTime -> NominalDiffTime -> NominalDiffTime
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
$cmin :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
$cmax :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
>= :: NominalDiffTime -> NominalDiffTime -> Bool
$c>= :: NominalDiffTime -> NominalDiffTime -> Bool
> :: NominalDiffTime -> NominalDiffTime -> Bool
$c> :: NominalDiffTime -> NominalDiffTime -> Bool
<= :: NominalDiffTime -> NominalDiffTime -> Bool
$c<= :: NominalDiffTime -> NominalDiffTime -> Bool
< :: NominalDiffTime -> NominalDiffTime -> Bool
$c< :: NominalDiffTime -> NominalDiffTime -> Bool
compare :: NominalDiffTime -> NominalDiffTime -> Ordering
$ccompare :: NominalDiffTime -> NominalDiffTime -> Ordering
Ord)
deriving newtype (NominalDiffTime -> ()
forall a. (a -> ()) -> NFData a
rnf :: NominalDiffTime -> ()
$crnf :: NominalDiffTime -> ()
NFData)
toMicroseconds :: NominalDiffTime -> Micros
toMicroseconds :: NominalDiffTime -> Int64
toMicroseconds = NominalDiffTime -> Int64
_microseconds
{-# INLINE toMicroseconds #-}
fromMicroseconds :: Micros -> NominalDiffTime
fromMicroseconds :: Int64 -> NominalDiffTime
fromMicroseconds = Int64 -> NominalDiffTime
NominalDiffTime
{-# INLINE fromMicroseconds #-}
instance AdditiveGroup NominalDiffTime where
zeroV :: NominalDiffTime
zeroV = Int64 -> NominalDiffTime
NominalDiffTime Int64
0
NominalDiffTime Int64
a ^+^ :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
^+^ NominalDiffTime Int64
b = Int64 -> NominalDiffTime
NominalDiffTime (Int64
a forall a. Num a => a -> a -> a
+ Int64
b)
negateV :: NominalDiffTime -> NominalDiffTime
negateV (NominalDiffTime Int64
v) = Int64 -> NominalDiffTime
NominalDiffTime (-Int64
v)
NominalDiffTime Int64
a ^-^ :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
^-^ NominalDiffTime Int64
b = Int64 -> NominalDiffTime
NominalDiffTime (Int64
a forall a. Num a => a -> a -> a
- Int64
b)
{-# INLINE zeroV #-}
{-# INLINE (^+^) #-}
{-# INLINE negateV #-}
{-# INLINE (^-^) #-}
instance VectorSpace NominalDiffTime where
type Scalar NominalDiffTime = Rational
Scalar NominalDiffTime
s *^ :: Scalar NominalDiffTime -> NominalDiffTime -> NominalDiffTime
*^ (NominalDiffTime Int64
m) = Int64 -> NominalDiffTime
NominalDiffTime forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round (Scalar NominalDiffTime
s forall a. Num a => a -> a -> a
* forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
m)
{-# INLINE (*^) #-}
instance Serialize NominalDiffTime where
put :: Putter NominalDiffTime
put (NominalDiffTime Int64
m) = Putter Int64
putInt64le Int64
m
get :: Get NominalDiffTime
get = Int64 -> NominalDiffTime
NominalDiffTime forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Int64
getInt64le
{-# INLINE put #-}
{-# INLINE get #-}
toSeconds :: NominalDiffTime -> Decimal
toSeconds :: NominalDiffTime -> Decimal
toSeconds (NominalDiffTime Int64
m) = forall a b. (Real a, Fractional b) => a -> b
realToFrac Int64
m forall a. Fractional a => a -> a -> a
/ Decimal
1000000
{-# INLINE toSeconds #-}
fromSeconds :: Decimal -> NominalDiffTime
fromSeconds :: Decimal -> NominalDiffTime
fromSeconds Decimal
d = Int64 -> NominalDiffTime
NominalDiffTime forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round forall a b. (a -> b) -> a -> b
$ Decimal
d forall a. Num a => a -> a -> a
* Decimal
1000000
{-# INLINE fromSeconds #-}
nominalDay :: NominalDiffTime
nominalDay :: NominalDiffTime
nominalDay = Int64 -> NominalDiffTime
NominalDiffTime forall a b. (a -> b) -> a -> b
$ Int64
86400 forall a. Num a => a -> a -> a
* Int64
1000000
{-# INLINE nominalDay #-}
toPosixTimestampMicros :: UTCTime -> Micros
toPosixTimestampMicros :: UTCTime -> Int64
toPosixTimestampMicros = POSIXTime -> Int64
toTimestampMicros forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> POSIXTime
toPosix
{-# INLINE toPosixTimestampMicros #-}
fromPosixTimestampMicros :: Micros -> UTCTime
fromPosixTimestampMicros :: Int64 -> UTCTime
fromPosixTimestampMicros = POSIXTime -> UTCTime
fromPosix forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> POSIXTime
fromTimestampMicros
{-# INLINE fromPosixTimestampMicros #-}
newtype UTCTime = UTCTime { UTCTime -> NominalDiffTime
_utcTime :: NominalDiffTime }
deriving (UTCTime -> UTCTime -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UTCTime -> UTCTime -> Bool
$c/= :: UTCTime -> UTCTime -> Bool
== :: UTCTime -> UTCTime -> Bool
$c== :: UTCTime -> UTCTime -> Bool
Eq, Eq UTCTime
UTCTime -> UTCTime -> Bool
UTCTime -> UTCTime -> Ordering
UTCTime -> UTCTime -> UTCTime
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: UTCTime -> UTCTime -> UTCTime
$cmin :: UTCTime -> UTCTime -> UTCTime
max :: UTCTime -> UTCTime -> UTCTime
$cmax :: UTCTime -> UTCTime -> UTCTime
>= :: UTCTime -> UTCTime -> Bool
$c>= :: UTCTime -> UTCTime -> Bool
> :: UTCTime -> UTCTime -> Bool
$c> :: UTCTime -> UTCTime -> Bool
<= :: UTCTime -> UTCTime -> Bool
$c<= :: UTCTime -> UTCTime -> Bool
< :: UTCTime -> UTCTime -> Bool
$c< :: UTCTime -> UTCTime -> Bool
compare :: UTCTime -> UTCTime -> Ordering
$ccompare :: UTCTime -> UTCTime -> Ordering
Ord)
deriving (forall x. Rep UTCTime x -> UTCTime
forall x. UTCTime -> Rep UTCTime x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UTCTime x -> UTCTime
$cfrom :: forall x. UTCTime -> Rep UTCTime x
Generic)
deriving newtype (UTCTime -> ()
forall a. (a -> ()) -> NFData a
rnf :: UTCTime -> ()
$crnf :: UTCTime -> ()
NFData)
deriving newtype (Get UTCTime
Putter UTCTime
forall t. Putter t -> Get t -> Serialize t
get :: Get UTCTime
$cget :: Get UTCTime
put :: Putter UTCTime
$cput :: Putter UTCTime
Serialize)
instance AffineSpace UTCTime where
type Diff UTCTime = NominalDiffTime
UTCTime NominalDiffTime
a .-. :: UTCTime -> UTCTime -> Diff UTCTime
.-. UTCTime NominalDiffTime
b = NominalDiffTime
a forall v. AdditiveGroup v => v -> v -> v
^-^ NominalDiffTime
b
UTCTime NominalDiffTime
a .+^ :: UTCTime -> Diff UTCTime -> UTCTime
.+^ Diff UTCTime
b = NominalDiffTime -> UTCTime
UTCTime (NominalDiffTime
a forall v. AdditiveGroup v => v -> v -> v
^+^ Diff UTCTime
b)
{-# INLINE (.-.) #-}
{-# INLINE (.+^) #-}
getCurrentTime :: IO UTCTime
getCurrentTime :: IO UTCTime
getCurrentTime = NominalDiffTime -> UTCTime
UTCTime forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall v. AdditiveGroup v => v -> v -> v
^+^ UTCTime -> NominalDiffTime
_utcTime UTCTime
posixEpoch) forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> NominalDiffTime
_posixTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO POSIXTime
getPOSIXTime
{-# INLINE getCurrentTime #-}
day :: Lens' UTCTime ModifiedJulianDay
day :: Lens' UTCTime ModifiedJulianDay
day = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
(ModifiedJulianDate -> ModifiedJulianDay
_mjdDay forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> ModifiedJulianDate
toModifiedJulianDate)
(\UTCTime
a ModifiedJulianDay
b -> ModifiedJulianDate -> UTCTime
fromModifiedJulianDate forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s t a b. ASetter s t a b -> b -> s -> t
set Lens' ModifiedJulianDate ModifiedJulianDay
mjdDay ModifiedJulianDay
b forall a b. (a -> b) -> a -> b
$ UTCTime -> ModifiedJulianDate
toModifiedJulianDate UTCTime
a)
{-# INLINE day #-}
dayTime :: Lens' UTCTime NominalDiffTime
dayTime :: Lens' UTCTime NominalDiffTime
dayTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
(ModifiedJulianDate -> NominalDiffTime
_mjdTime forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> ModifiedJulianDate
toModifiedJulianDate)
(\UTCTime
a NominalDiffTime
b -> ModifiedJulianDate -> UTCTime
fromModifiedJulianDate forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s t a b. ASetter s t a b -> b -> s -> t
set Lens' ModifiedJulianDate NominalDiffTime
mjdTime NominalDiffTime
b forall a b. (a -> b) -> a -> b
$ UTCTime -> ModifiedJulianDate
toModifiedJulianDate UTCTime
a)
{-# INLINE dayTime #-}
fromDayAndDayTime :: ModifiedJulianDay -> NominalDiffTime -> UTCTime
fromDayAndDayTime :: ModifiedJulianDay -> NominalDiffTime -> UTCTime
fromDayAndDayTime ModifiedJulianDay
d NominalDiffTime
t = ModifiedJulianDate -> UTCTime
fromModifiedJulianDate forall a b. (a -> b) -> a -> b
$ ModifiedJulianDay -> NominalDiffTime -> ModifiedJulianDate
ModifiedJulianDate ModifiedJulianDay
d NominalDiffTime
t
{-# INLINE fromDayAndDayTime #-}
posixEpoch :: UTCTime
posixEpoch :: UTCTime
posixEpoch = NominalDiffTime -> UTCTime
UTCTime (forall a b. (Integral a, Num b) => a -> b
fromIntegral Day
d forall v. VectorSpace v => Scalar v -> v -> v
*^ NominalDiffTime
nominalDay)
where
ModifiedJulianDay Day
d = ModifiedJulianDay
posixEpochDay
{-# INLINE posixEpoch #-}
mjdEpoch :: UTCTime
mjdEpoch :: UTCTime
mjdEpoch = NominalDiffTime -> UTCTime
UTCTime forall v. AdditiveGroup v => v
zeroV
{-# INLINE mjdEpoch #-}
newtype POSIXTime = POSIXTime { POSIXTime -> NominalDiffTime
_posixTime :: NominalDiffTime }
deriving (POSIXTime -> POSIXTime -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: POSIXTime -> POSIXTime -> Bool
$c/= :: POSIXTime -> POSIXTime -> Bool
== :: POSIXTime -> POSIXTime -> Bool
$c== :: POSIXTime -> POSIXTime -> Bool
Eq, Eq POSIXTime
POSIXTime -> POSIXTime -> Bool
POSIXTime -> POSIXTime -> Ordering
POSIXTime -> POSIXTime -> POSIXTime
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: POSIXTime -> POSIXTime -> POSIXTime
$cmin :: POSIXTime -> POSIXTime -> POSIXTime
max :: POSIXTime -> POSIXTime -> POSIXTime
$cmax :: POSIXTime -> POSIXTime -> POSIXTime
>= :: POSIXTime -> POSIXTime -> Bool
$c>= :: POSIXTime -> POSIXTime -> Bool
> :: POSIXTime -> POSIXTime -> Bool
$c> :: POSIXTime -> POSIXTime -> Bool
<= :: POSIXTime -> POSIXTime -> Bool
$c<= :: POSIXTime -> POSIXTime -> Bool
< :: POSIXTime -> POSIXTime -> Bool
$c< :: POSIXTime -> POSIXTime -> Bool
compare :: POSIXTime -> POSIXTime -> Ordering
$ccompare :: POSIXTime -> POSIXTime -> Ordering
Ord)
deriving newtype (POSIXTime -> ()
forall a. (a -> ()) -> NFData a
rnf :: POSIXTime -> ()
$crnf :: POSIXTime -> ()
NFData)
toTimestampMicros :: POSIXTime -> Micros
toTimestampMicros :: POSIXTime -> Int64
toTimestampMicros = NominalDiffTime -> Int64
_microseconds forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> NominalDiffTime
_posixTime
{-# INLINE toTimestampMicros #-}
fromTimestampMicros :: Micros -> POSIXTime
fromTimestampMicros :: Int64 -> POSIXTime
fromTimestampMicros = NominalDiffTime -> POSIXTime
POSIXTime forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> NominalDiffTime
fromMicroseconds
{-# INLINE fromTimestampMicros #-}
posixEpochDay :: ModifiedJulianDay
posixEpochDay :: ModifiedJulianDay
posixEpochDay = Day -> ModifiedJulianDay
ModifiedJulianDay Day
40587
{-# INLINE posixEpochDay #-}
getPOSIXTime :: IO POSIXTime
getPOSIXTime :: IO POSIXTime
getPOSIXTime = NominalDiffTime -> POSIXTime
POSIXTime forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> NominalDiffTime
NominalDiffTime forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO Int64
getSystemTimeMicros
{-# INLINE getPOSIXTime #-}
toPosix :: UTCTime -> POSIXTime
toPosix :: UTCTime -> POSIXTime
toPosix UTCTime
t = NominalDiffTime -> POSIXTime
POSIXTime forall a b. (a -> b) -> a -> b
$ UTCTime -> NominalDiffTime
_utcTime UTCTime
t forall v. AdditiveGroup v => v -> v -> v
^-^ UTCTime -> NominalDiffTime
_utcTime UTCTime
posixEpoch
{-# INLINE toPosix #-}
fromPosix :: POSIXTime -> UTCTime
fromPosix :: POSIXTime -> UTCTime
fromPosix POSIXTime
p = NominalDiffTime -> UTCTime
UTCTime forall a b. (a -> b) -> a -> b
$ POSIXTime -> NominalDiffTime
_posixTime POSIXTime
p forall v. AdditiveGroup v => v -> v -> v
^+^ UTCTime -> NominalDiffTime
_utcTime UTCTime
posixEpoch
{-# INLINE fromPosix #-}
newtype ModifiedJulianDay = ModifiedJulianDay Day
deriving newtype (ModifiedJulianDay -> ModifiedJulianDay -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
$c/= :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
== :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
$c== :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
Eq, Eq ModifiedJulianDay
ModifiedJulianDay -> ModifiedJulianDay -> Bool
ModifiedJulianDay -> ModifiedJulianDay -> Ordering
ModifiedJulianDay -> ModifiedJulianDay -> ModifiedJulianDay
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModifiedJulianDay -> ModifiedJulianDay -> ModifiedJulianDay
$cmin :: ModifiedJulianDay -> ModifiedJulianDay -> ModifiedJulianDay
max :: ModifiedJulianDay -> ModifiedJulianDay -> ModifiedJulianDay
$cmax :: ModifiedJulianDay -> ModifiedJulianDay -> ModifiedJulianDay
>= :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
$c>= :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
> :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
$c> :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
<= :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
$c<= :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
< :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
$c< :: ModifiedJulianDay -> ModifiedJulianDay -> Bool
compare :: ModifiedJulianDay -> ModifiedJulianDay -> Ordering
$ccompare :: ModifiedJulianDay -> ModifiedJulianDay -> Ordering
Ord, ModifiedJulianDay -> ()
forall a. (a -> ()) -> NFData a
rnf :: ModifiedJulianDay -> ()
$crnf :: ModifiedJulianDay -> ()
NFData)
data ModifiedJulianDate = ModifiedJulianDate
{ ModifiedJulianDate -> ModifiedJulianDay
_mjdDay :: !ModifiedJulianDay
, ModifiedJulianDate -> NominalDiffTime
_mjdTime :: !NominalDiffTime
}
deriving (ModifiedJulianDate -> ModifiedJulianDate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
$c/= :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
== :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
$c== :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
Eq, Eq ModifiedJulianDate
ModifiedJulianDate -> ModifiedJulianDate -> Bool
ModifiedJulianDate -> ModifiedJulianDate -> Ordering
ModifiedJulianDate -> ModifiedJulianDate -> ModifiedJulianDate
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModifiedJulianDate -> ModifiedJulianDate -> ModifiedJulianDate
$cmin :: ModifiedJulianDate -> ModifiedJulianDate -> ModifiedJulianDate
max :: ModifiedJulianDate -> ModifiedJulianDate -> ModifiedJulianDate
$cmax :: ModifiedJulianDate -> ModifiedJulianDate -> ModifiedJulianDate
>= :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
$c>= :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
> :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
$c> :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
<= :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
$c<= :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
< :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
$c< :: ModifiedJulianDate -> ModifiedJulianDate -> Bool
compare :: ModifiedJulianDate -> ModifiedJulianDate -> Ordering
$ccompare :: ModifiedJulianDate -> ModifiedJulianDate -> Ordering
Ord, forall x. Rep ModifiedJulianDate x -> ModifiedJulianDate
forall x. ModifiedJulianDate -> Rep ModifiedJulianDate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModifiedJulianDate x -> ModifiedJulianDate
$cfrom :: forall x. ModifiedJulianDate -> Rep ModifiedJulianDate x
Generic)
deriving anyclass (ModifiedJulianDate -> ()
forall a. (a -> ()) -> NFData a
rnf :: ModifiedJulianDate -> ()
$crnf :: ModifiedJulianDate -> ()
NFData)
mjdDay :: Lens' ModifiedJulianDate ModifiedJulianDay
mjdDay :: Lens' ModifiedJulianDate ModifiedJulianDay
mjdDay = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ModifiedJulianDate -> ModifiedJulianDay
_mjdDay forall a b. (a -> b) -> a -> b
$ \ModifiedJulianDate
a ModifiedJulianDay
b -> ModifiedJulianDate
a { _mjdDay :: ModifiedJulianDay
_mjdDay = ModifiedJulianDay
b }
{-# INLINE mjdDay #-}
mjdTime :: Lens' ModifiedJulianDate NominalDiffTime
mjdTime :: Lens' ModifiedJulianDate NominalDiffTime
mjdTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ModifiedJulianDate -> NominalDiffTime
_mjdTime forall a b. (a -> b) -> a -> b
$ \ModifiedJulianDate
a NominalDiffTime
b -> ModifiedJulianDate
a { _mjdTime :: NominalDiffTime
_mjdTime = NominalDiffTime
b }
{-# INLINE mjdTime #-}
toModifiedJulianDate :: UTCTime -> ModifiedJulianDate
toModifiedJulianDate :: UTCTime -> ModifiedJulianDate
toModifiedJulianDate (UTCTime (NominalDiffTime Int64
m)) = ModifiedJulianDay -> NominalDiffTime -> ModifiedJulianDate
ModifiedJulianDate
(Day -> ModifiedJulianDay
ModifiedJulianDay (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
d))
(Int64 -> NominalDiffTime
NominalDiffTime Int64
t)
where
(Int64
d, Int64
t) = forall a. Integral a => a -> a -> (a, a)
divMod Int64
m Int64
n
NominalDiffTime Int64
n = NominalDiffTime
nominalDay
{-# INLINE toModifiedJulianDate #-}
fromModifiedJulianDate :: ModifiedJulianDate -> UTCTime
fromModifiedJulianDate :: ModifiedJulianDate -> UTCTime
fromModifiedJulianDate (ModifiedJulianDate (ModifiedJulianDay Day
d) NominalDiffTime
t)
= NominalDiffTime -> UTCTime
UTCTime forall a b. (a -> b) -> a -> b
$ (forall a b. (Integral a, Num b) => a -> b
fromIntegral Day
d forall v. VectorSpace v => Scalar v -> v -> v
*^ NominalDiffTime
nominalDay) forall v. AdditiveGroup v => v -> v -> v
^+^ NominalDiffTime
t
{-# INLINE fromModifiedJulianDate #-}