{-# OPTIONS_GHC -fno-warn-orphans #-}
module Data.UnixTime.Diff (
diffUnixTime,
addUnixDiffTime,
secondsToUnixDiffTime,
microSecondsToUnixDiffTime,
) where
import Data.Int
import Data.UnixTime.Types
import Foreign.C.Types
normDiff :: CTime -> Int64 -> UnixDiffTime
normDiff :: CTime -> Int64 -> UnixDiffTime
normDiff CTime
sec Int64
usec
| CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
> CTime
0 Bool -> Bool -> Bool
&& Int64
u Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
< Int64
0 = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (CTime
s CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
1) (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64
u Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int64
forall a. Num a => a
micro))
| CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
< CTime
0 Bool -> Bool -> Bool
&& Int64
u Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> Int64
0 = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (CTime
s CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
1) (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64
u Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Int64
forall a. Num a => a
micro))
| Bool
otherwise = CTime -> Int32 -> UnixDiffTime
UnixDiffTime CTime
s (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
u)
where
(Int64
q, Int64
u) = Int64
usec Int64 -> Int64 -> (Int64, Int64)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int64
forall a. Num a => a
micro
s :: CTime
s = CTime
sec CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ Int64 -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
q
normTime :: CTime -> Int64 -> UnixTime
normTime :: CTime -> Int64 -> UnixTime
normTime CTime
sec Int64
usec = CTime -> Int32 -> UnixTime
UnixTime (CTime
sec CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ Int64 -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
q) (Int64 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
u)
where
(Int64
q, Int64
u) = Int64
usec Int64 -> Int64 -> (Int64, Int64)
forall a. Integral a => a -> a -> (a, a)
`divMod` Int64
forall a. Num a => a
micro
normalize :: UnixDiffTime -> UnixDiffTime
normalize :: UnixDiffTime -> UnixDiffTime
normalize (UnixDiffTime CTime
s Int32
u) = CTime -> Int64 -> UnixDiffTime
normDiff CTime
s (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u)
toMicro :: UnixDiffTime -> Integer
toMicro :: UnixDiffTime -> Integer
toMicro (UnixDiffTime (CTime Int64
s) Int32
u) = Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger Int64
s Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
forall a. Num a => a
micro Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger Int32
u
fromMicro :: Integer -> UnixDiffTime
fromMicro :: Integer -> UnixDiffTime
fromMicro Integer
n = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (Integer -> CTime
forall a. Num a => Integer -> a
fromInteger Integer
s) (Integer -> Int32
forall a. Num a => Integer -> a
fromInteger Integer
u)
where
(Integer
s, Integer
u) = Integer
n Integer -> Integer -> (Integer, Integer)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Integer
forall a. Num a => a
micro
micro :: Num a => a
micro :: forall a. Num a => a
micro = a
1000000
instance Num UnixDiffTime where
UnixDiffTime CTime
s1 Int32
u1 + :: UnixDiffTime -> UnixDiffTime -> UnixDiffTime
+ UnixDiffTime CTime
s2 Int32
u2 =
CTime -> Int64 -> UnixDiffTime
normDiff (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)
UnixDiffTime CTime
s1 Int32
u1 - :: UnixDiffTime -> UnixDiffTime -> UnixDiffTime
- UnixDiffTime CTime
s2 Int32
u2 =
CTime -> Int64 -> UnixDiffTime
normDiff (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)
UnixDiffTime
x * :: UnixDiffTime -> UnixDiffTime -> UnixDiffTime
* UnixDiffTime
y = Integer -> UnixDiffTime
fromMicro (UnixDiffTime -> Integer
toMicro UnixDiffTime
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* UnixDiffTime -> Integer
toMicro UnixDiffTime
y Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`quot` Integer
forall a. Num a => a
micro)
negate :: UnixDiffTime -> UnixDiffTime
negate (UnixDiffTime CTime
s Int32
u) = CTime -> Int64 -> UnixDiffTime
normDiff (CTime -> CTime
forall a. Num a => a -> a
negate CTime
s) (Int64 -> Int64
forall a. Num a => a -> a
negate (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u))
abs :: UnixDiffTime -> UnixDiffTime
abs UnixDiffTime
x = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (CTime -> CTime
forall a. Num a => a -> a
abs CTime
s) (Int32 -> Int32
forall a. Num a => a -> a
abs Int32
u)
where
UnixDiffTime CTime
s Int32
u = UnixDiffTime -> UnixDiffTime
normalize UnixDiffTime
x
signum :: UnixDiffTime -> UnixDiffTime
signum UnixDiffTime
x
| CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
> CTime
0 Bool -> Bool -> Bool
|| Int32
u Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
> Int32
0 = UnixDiffTime
1
| CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
< CTime
0 Bool -> Bool -> Bool
|| Int32
u Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
0 = -UnixDiffTime
1
| Bool
otherwise = UnixDiffTime
0
where
UnixDiffTime CTime
s Int32
u = UnixDiffTime -> UnixDiffTime
normalize UnixDiffTime
x
fromInteger :: Integer -> UnixDiffTime
fromInteger Integer
i = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (Integer -> CTime
forall a. Num a => Integer -> a
fromInteger Integer
i) Int32
0
{-# RULES "Integral->UnixDiffTime" fromIntegral = secondsToUnixDiffTime #-}
instance Real UnixDiffTime where
toRational :: UnixDiffTime -> Rational
toRational = UnixDiffTime -> Rational
forall a. Fractional a => UnixDiffTime -> a
toFractional
{-# RULES "UnixDiffTime->Fractional" realToFrac = toFractional #-}
diffUnixTime :: UnixTime -> UnixTime -> UnixDiffTime
diffUnixTime :: UnixTime -> UnixTime -> UnixDiffTime
diffUnixTime (UnixTime CTime
s1 Int32
u1) (UnixTime CTime
s2 Int32
u2) =
CTime -> Int64 -> UnixDiffTime
normDiff (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)
addUnixDiffTime :: UnixTime -> UnixDiffTime -> UnixTime
addUnixDiffTime :: UnixTime -> UnixDiffTime -> UnixTime
addUnixDiffTime (UnixTime CTime
s1 Int32
u1) (UnixDiffTime CTime
s2 Int32
u2) =
CTime -> Int64 -> UnixTime
normTime (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
s2) (Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u1 Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
u2)
secondsToUnixDiffTime :: Integral a => a -> UnixDiffTime
secondsToUnixDiffTime :: forall a. Integral a => a -> UnixDiffTime
secondsToUnixDiffTime a
sec = CTime -> Int32 -> UnixDiffTime
UnixDiffTime (a -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
sec) Int32
0
{-# INLINE secondsToUnixDiffTime #-}
microSecondsToUnixDiffTime :: Integral a => a -> UnixDiffTime
microSecondsToUnixDiffTime :: forall a. Integral a => a -> UnixDiffTime
microSecondsToUnixDiffTime = Integer -> UnixDiffTime
fromMicro (Integer -> UnixDiffTime) -> (a -> Integer) -> a -> UnixDiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Integer
forall a. Integral a => a -> Integer
toInteger
{-# INLINE microSecondsToUnixDiffTime #-}
toFractional :: Fractional a => UnixDiffTime -> a
toFractional :: forall a. Fractional a => UnixDiffTime -> a
toFractional (UnixDiffTime CTime
s Int32
u) = CTime -> a
forall a b. (Real a, Fractional b) => a -> b
realToFrac CTime
s a -> a -> a
forall a. Num a => a -> a -> a
+ Int32 -> a
forall a b. (Real a, Fractional b) => a -> b
realToFrac Int32
u a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
1000000
{-# SPECIALIZE toFractional :: UnixDiffTime -> Double #-}