{-# LINE 1 "src/System/Posix/Clock.hsc" #-}
{-# LANGUAGE UnicodeSyntax #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleContexts #-}

-- | POSIX clocks.
module System.Posix.Clock (
    TimeSpec,
    timeSpecSeconds,
    timeSpecNanos,
    mkTimeSpec,
    timeSpecV,
    timeSpecToInt64,

    Clock(..),
    monotonicClock,
    realtimeClock,
    processTimeClock,
    threadTimeClock,

    getProcessClock,
    getClockResolution,
    getClockTime,
    setClockTime,
    clockSleep,
    clockSleepAbs,
  ) where

import Data.Int
import Data.Word
import Data.Ratio (numerator)
import Data.List (unfoldr)
import Control.Applicative ((<$>), (<*>))
import Control.Monad.Base
import Foreign.Ptr (Ptr, nullPtr)
import Foreign.Storable (Storable(..))
import Foreign.Marshal.Alloc (alloca)
import Foreign.Marshal.Utils (with)
import Foreign.C.Types (CULong)

{-# LINE 42 "src/System/Posix/Clock.hsc" #-}
import Foreign.C.Types (CInt(..), CTime(..))

{-# LINE 46 "src/System/Posix/Clock.hsc" #-}
import Foreign.C.Error (getErrno, eINTR, throwErrno, throwErrnoIfMinus1_)

{-# LINE 48 "src/System/Posix/Clock.hsc" #-}
import System.Posix.Types (CPid(..))

{-# LINE 50 "src/System/Posix/Clock.hsc" #-}
import System.Posix.Types (ProcessID)

{-# LINE 54 "src/System/Posix/Clock.hsc" #-}








nsPerSecond ∷ Num α ⇒ α
nsPerSecond :: forall α. Num α => α
nsPerSecond = α
1000000000
{-# INLINE nsPerSecond #-}

minSecsInInt, minNsInInt ∷ Int
(Int
minSecsInInt, Int
minNsInInt) = (Int
forall a. Bounded a => a
minBound ∷ Int) Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`divMod` Int
forall α. Num α => α
nsPerSecond

maxSecsInInt, maxNsInInt ∷ Int
(Int
maxSecsInInt, Int
maxNsInInt) = (Int
forall a. Bounded a => a
maxBound ∷ Int) Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`divMod` Int
forall α. Num α => α
nsPerSecond

-- | Mirrors /struct timespec/.
data TimeSpec = TimeSpec { TimeSpec -> CTime
timeSpecSeconds ∷ CTime
                         , TimeSpec -> CULong
timeSpecNanos   ∷ CULong
                         } deriving (TimeSpec -> TimeSpec -> Bool
(TimeSpec -> TimeSpec -> Bool)
-> (TimeSpec -> TimeSpec -> Bool) -> Eq TimeSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TimeSpec -> TimeSpec -> Bool
== :: TimeSpec -> TimeSpec -> Bool
$c/= :: TimeSpec -> TimeSpec -> Bool
/= :: TimeSpec -> TimeSpec -> Bool
Eq, Int -> TimeSpec -> ShowS
[TimeSpec] -> ShowS
TimeSpec -> String
(Int -> TimeSpec -> ShowS)
-> (TimeSpec -> String) -> ([TimeSpec] -> ShowS) -> Show TimeSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TimeSpec -> ShowS
showsPrec :: Int -> TimeSpec -> ShowS
$cshow :: TimeSpec -> String
show :: TimeSpec -> String
$cshowList :: [TimeSpec] -> ShowS
showList :: [TimeSpec] -> ShowS
Show)

-- | Create a 'TimeSpec' from amounts of seconds and nanoseconds.
mkTimeSpec ∷ CTime → CULong → TimeSpec
mkTimeSpec :: CTime -> CULong -> TimeSpec
mkTimeSpec CTime
s CULong
ns | CULong
ns CULong -> CULong -> Bool
forall a. Ord a => a -> a -> Bool
< CULong
forall α. Num α => α
nsPerSecond = CTime -> CULong -> TimeSpec
TimeSpec CTime
s CULong
ns
                | Bool
otherwise        = CTime -> CULong -> TimeSpec
TimeSpec (CTime
s CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CULong -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral CULong
q) CULong
r
  where (CULong
q, CULong
r) = CULong
ns CULong -> CULong -> (CULong, CULong)
forall a. Integral a => a -> a -> (a, a)
`quotRem` CULong
forall α. Num α => α
nsPerSecond 

-- | Convert a 'TimeSpec' to a pair of its components.
--   Useful as a view pattern.
timeSpecV ∷ TimeSpec → (CTime, CULong)
timeSpecV :: TimeSpec -> (CTime, CULong)
timeSpecV (TimeSpec CTime
s CULong
ns) = (CTime
s, CULong
ns)
{-# INLINE timeSpecV #-}

instance Ord TimeSpec where
  (TimeSpec CTime
s1 CULong
ns1) compare :: TimeSpec -> TimeSpec -> Ordering
`compare` (TimeSpec CTime
s2 CULong
ns2) = 
    case CTime
s1 CTime -> CTime -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` CTime
s2 of
      Ordering
EQ → CULong
ns1 CULong -> CULong -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` CULong
ns2
      Ordering
x  → Ordering
x

instance Bounded TimeSpec where
  minBound :: TimeSpec
minBound = CTime -> CULong -> TimeSpec
TimeSpec (Int64 -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64
forall a. Bounded a => a
minBound ∷ Int64)) CULong
0
{-# LINE 97 "src/System/Posix/Clock.hsc" #-}
  maxBound = TimeSpec (fromIntegral (maxBound ∷ Int64))
{-# LINE 98 "src/System/Posix/Clock.hsc" #-}
                      (nsPerSecond - 1)

instance Num TimeSpec where
  (TimeSpec CTime
s1 CULong
ns1) * :: TimeSpec -> TimeSpec -> TimeSpec
* (TimeSpec CTime
s2 CULong
ns2) =
    CTime -> CULong -> TimeSpec
mkTimeSpec (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
* CTime
s2 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
* CTime
forall α. Num α => α
nsPerSecond CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+
                CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
* (CULong -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral CULong
ns2) CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
s2 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
* (CULong -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral CULong
ns1) CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+
                (Word64 -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
q)) (CULong -> TimeSpec) -> CULong -> TimeSpec
forall a b. (a -> b) -> a -> b
$ Word64 -> CULong
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
r
      where (Word64
q, Word64
r) = ((CULong -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral CULong
ns1 ∷ Word64) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
*
                      (CULong -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral CULong
ns2 ∷ Word64)) Word64 -> Word64 -> (Word64, Word64)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Word64
forall α. Num α => α
nsPerSecond
  (TimeSpec CTime
s1 CULong
ns1) + :: TimeSpec -> TimeSpec -> TimeSpec
+ (TimeSpec CTime
s2 CULong
ns2) = CTime -> CULong -> TimeSpec
mkTimeSpec (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
+ CTime
s2) (CULong
ns1 CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
+ CULong
ns2)
  (TimeSpec CTime
s1 CULong
ns1) - :: TimeSpec -> TimeSpec -> TimeSpec
- (TimeSpec CTime
s2 CULong
ns2) =
    if CULong
ns1 CULong -> CULong -> Bool
forall a. Ord a => a -> a -> Bool
< CULong
ns2 then CTime -> CULong -> TimeSpec
TimeSpec (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
s2 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
1) (CULong
forall α. Num α => α
nsPerSecond CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
- CULong
ns2 CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
+ CULong
ns1)
                 else CTime -> CULong -> TimeSpec
TimeSpec (CTime
s1 CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
s2) (CULong
ns1 CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
- CULong
ns2)
  negate :: TimeSpec -> TimeSpec
negate (TimeSpec CTime
s CULong
ns) = CTime -> CULong -> TimeSpec
mkTimeSpec ((-CTime
s) CTime -> CTime -> CTime
forall a. Num a => a -> a -> a
- CTime
1) (CULong
forall α. Num α => α
nsPerSecond CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
- CULong
ns)
  abs :: TimeSpec -> TimeSpec
abs ts :: TimeSpec
ts@(TimeSpec CTime
s CULong
_) = if CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
>= CTime
0 then TimeSpec
ts else TimeSpec -> TimeSpec
forall a. Num a => a -> a
negate TimeSpec
ts
  signum :: TimeSpec -> TimeSpec
signum (TimeSpec CTime
s CULong
ns) | CTime
s CTime -> CTime -> Bool
forall a. Ord a => a -> a -> Bool
< CTime
0     = CTime -> CULong -> TimeSpec
TimeSpec (-CTime
1) (CULong
forall α. Num α => α
nsPerSecond CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
- CULong
1)
                         | Bool
otherwise = CTime -> CULong -> TimeSpec
TimeSpec CTime
0 (CULong -> TimeSpec) -> CULong -> TimeSpec
forall a b. (a -> b) -> a -> b
$ CULong -> CULong
forall a. Num a => a -> a
signum CULong
ns
  fromInteger :: Integer -> TimeSpec
fromInteger Integer
i = CTime -> CULong -> TimeSpec
TimeSpec (Integer -> CTime
forall a. Num a => Integer -> a
fromInteger Integer
s) (Integer -> CULong
forall a. Num a => Integer -> a
fromInteger Integer
ns)
                    where (Integer
s, Integer
ns) = Integer
i Integer -> Integer -> (Integer, Integer)
forall a. Integral a => a -> a -> (a, a)
`divMod` Integer
forall α. Num α => α
nsPerSecond

instance Real TimeSpec where
  toRational :: TimeSpec -> Rational
toRational (TimeSpec CTime
s CULong
ns) = CTime -> Rational
forall a. Real a => a -> Rational
toRational CTime
s Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
* Rational
forall α. Num α => α
nsPerSecond Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
+ CULong -> Rational
forall a. Real a => a -> Rational
toRational CULong
ns

instance Enum TimeSpec where
  succ :: TimeSpec -> TimeSpec
succ (TimeSpec CTime
s CULong
ns) | CULong
ns CULong -> CULong -> Bool
forall a. Eq a => a -> a -> Bool
== CULong
forall α. Num α => α
nsPerSecond CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
- CULong
1 = CTime -> CULong -> TimeSpec
TimeSpec (CTime -> CTime
forall a. Enum a => a -> a
succ CTime
s) CULong
0
                       | Bool
otherwise             = CTime -> CULong -> TimeSpec
TimeSpec CTime
s (CULong -> CULong
forall a. Enum a => a -> a
succ CULong
ns)
  pred :: TimeSpec -> TimeSpec
pred (TimeSpec CTime
s CULong
ns) | CULong
ns CULong -> CULong -> Bool
forall a. Eq a => a -> a -> Bool
== CULong
0   = CTime -> CULong -> TimeSpec
TimeSpec (CTime -> CTime
forall a. Enum a => a -> a
pred CTime
s) (CULong
forall α. Num α => α
nsPerSecond CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
- CULong
1)
                       | Bool
otherwise = CTime -> CULong -> TimeSpec
TimeSpec CTime
s (CULong
ns CULong -> CULong -> CULong
forall a. Num a => a -> a -> a
- CULong
1)
  toEnum :: Int -> TimeSpec
toEnum Int
i = CTime -> CULong -> TimeSpec
TimeSpec (Int -> CTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
s) (Int -> CULong
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ns)
               where (Int
s, Int
ns) = Int
i Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`divMod` Int
forall α. Num α => α
nsPerSecond
  fromEnum :: TimeSpec -> Int
fromEnum (TimeSpec CTime
s CULong
ns) =
      if Int64
s' Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
< Int64
minSecs Bool -> Bool -> Bool
|| (Int64
s' Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
== Int64
minSecs Bool -> Bool -> Bool
&& CULong
ns CULong -> CULong -> Bool
forall a. Ord a => a -> a -> Bool
< CULong
minNs) Bool -> Bool -> Bool
||
         Int64
s' Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> Int64
maxSecs Bool -> Bool -> Bool
|| (Int64
s' Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
== Int64
maxSecs Bool -> Bool -> Bool
&& CULong
ns CULong -> CULong -> Bool
forall a. Ord a => a -> a -> Bool
> CULong
maxNs)
        then String -> Int
forall a. HasCallStack => String -> a
error String
"TimeSpec.fromEnum"
        else Int64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
s' Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
forall α. Num α => α
nsPerSecond Int -> Int -> Int
forall a. Num a => a -> a -> a
+ CULong -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral CULong
ns
    where s', minSecs, maxSecs ∷ Int64
{-# LINE 134 "src/System/Posix/Clock.hsc" #-}

{-# LINE 135 "src/System/Posix/Clock.hsc" #-}
          CTime Int64
s' = CTime
s

{-# LINE 139 "src/System/Posix/Clock.hsc" #-}
          minSecs :: Int64
minSecs = Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minSecsInInt
          maxSecs :: Int64
maxSecs = Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxSecsInInt
          minNs, maxNs ∷ CULong
          minNs :: CULong
minNs = Int -> CULong
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minNsInInt
          maxNs :: CULong
maxNs = Int -> CULong
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxNsInInt
  enumFrom :: TimeSpec -> [TimeSpec]
enumFrom TimeSpec
x = TimeSpec -> TimeSpec -> [TimeSpec]
forall a. Enum a => a -> a -> [a]
enumFromTo TimeSpec
x TimeSpec
forall a. Bounded a => a
maxBound
  enumFromThen :: TimeSpec -> TimeSpec -> [TimeSpec]
enumFromThen TimeSpec
x TimeSpec
y = TimeSpec -> TimeSpec -> TimeSpec -> [TimeSpec]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo TimeSpec
x TimeSpec
y TimeSpec
bound
    where bound :: TimeSpec
bound | TimeSpec
y TimeSpec -> TimeSpec -> Bool
forall a. Ord a => a -> a -> Bool
>= TimeSpec
x    = TimeSpec
forall a. Bounded a => a
maxBound
                | Bool
otherwise = TimeSpec
forall a. Bounded a => a
minBound
  enumFromTo :: TimeSpec -> TimeSpec -> [TimeSpec]
enumFromTo TimeSpec
x TimeSpec
y
    | TimeSpec
y TimeSpec -> TimeSpec -> Bool
forall a. Ord a => a -> a -> Bool
>= TimeSpec
x    = (TimeSpec -> Maybe (TimeSpec, TimeSpec)) -> TimeSpec -> [TimeSpec]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr (\TimeSpec
z → if TimeSpec
z TimeSpec -> TimeSpec -> Bool
forall a. Eq a => a -> a -> Bool
== TimeSpec
y then Maybe (TimeSpec, TimeSpec)
forall a. Maybe a
Nothing else (TimeSpec, TimeSpec) -> Maybe (TimeSpec, TimeSpec)
forall a. a -> Maybe a
Just (TimeSpec
z, TimeSpec
z TimeSpec -> TimeSpec -> TimeSpec
forall a. Num a => a -> a -> a
+ TimeSpec
1)) TimeSpec
x
    | Bool
otherwise = (TimeSpec -> Maybe (TimeSpec, TimeSpec)) -> TimeSpec -> [TimeSpec]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr (\TimeSpec
z → if TimeSpec
z TimeSpec -> TimeSpec -> Bool
forall a. Eq a => a -> a -> Bool
== TimeSpec
y then Maybe (TimeSpec, TimeSpec)
forall a. Maybe a
Nothing else (TimeSpec, TimeSpec) -> Maybe (TimeSpec, TimeSpec)
forall a. a -> Maybe a
Just (TimeSpec
z, TimeSpec
z TimeSpec -> TimeSpec -> TimeSpec
forall a. Num a => a -> a -> a
- TimeSpec
1)) TimeSpec
x
  enumFromThenTo :: TimeSpec -> TimeSpec -> TimeSpec -> [TimeSpec]
enumFromThenTo TimeSpec
x TimeSpec
n TimeSpec
y
      | TimeSpec
d TimeSpec -> TimeSpec -> Bool
forall a. Ord a => a -> a -> Bool
>= TimeSpec
0    =
          if TimeSpec
y TimeSpec -> TimeSpec -> Bool
forall a. Ord a => a -> a -> Bool
< TimeSpec
x
            then []
            else (TimeSpec -> Maybe (TimeSpec, TimeSpec)) -> TimeSpec -> [TimeSpec]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr (\TimeSpec
z → if TimeSpec
z TimeSpec -> TimeSpec -> Bool
forall a. Ord a => a -> a -> Bool
> TimeSpec
y then Maybe (TimeSpec, TimeSpec)
forall a. Maybe a
Nothing else (TimeSpec, TimeSpec) -> Maybe (TimeSpec, TimeSpec)
forall a. a -> Maybe a
Just (TimeSpec
z, TimeSpec
z TimeSpec -> TimeSpec -> TimeSpec
forall a. Num a => a -> a -> a
+ TimeSpec
d)) TimeSpec
x
      | Bool
otherwise =
          if TimeSpec
y TimeSpec -> TimeSpec -> Bool
forall a. Ord a => a -> a -> Bool
> TimeSpec
x
            then []
            else (TimeSpec -> Maybe (TimeSpec, TimeSpec)) -> TimeSpec -> [TimeSpec]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr (\TimeSpec
z → if TimeSpec
z TimeSpec -> TimeSpec -> Bool
forall a. Ord a => a -> a -> Bool
< TimeSpec
y then Maybe (TimeSpec, TimeSpec)
forall a. Maybe a
Nothing else (TimeSpec, TimeSpec) -> Maybe (TimeSpec, TimeSpec)
forall a. a -> Maybe a
Just (TimeSpec
z, TimeSpec
z TimeSpec -> TimeSpec -> TimeSpec
forall a. Num a => a -> a -> a
- TimeSpec
d)) TimeSpec
x
    where d :: TimeSpec
d = TimeSpec
n TimeSpec -> TimeSpec -> TimeSpec
forall a. Num a => a -> a -> a
- TimeSpec
x

instance Integral TimeSpec where
  toInteger :: TimeSpec -> Integer
toInteger (TimeSpec CTime
s CULong
ns) = (Rational -> Integer
forall a. Ratio a -> a
numerator (Rational -> Integer) -> Rational -> Integer
forall a b. (a -> b) -> a -> b
$ CTime -> Rational
forall a. Real a => a -> Rational
toRational CTime
s) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
forall α. Num α => α
nsPerSecond Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+
                              CULong -> Integer
forall a. Integral a => a -> Integer
toInteger CULong
ns
  -- TODO: Make it faster when the arguments are small enough
  quotRem :: TimeSpec -> TimeSpec -> (TimeSpec, TimeSpec)
quotRem TimeSpec
tsN TimeSpec
tsD = (Integer -> TimeSpec
forall a. Num a => Integer -> a
fromInteger Integer
q, Integer -> TimeSpec
forall a. Num a => Integer -> a
fromInteger Integer
r)
    where (Integer
q, Integer
r) = Integer -> Integer -> (Integer, Integer)
forall a. Integral a => a -> a -> (a, a)
quotRem (TimeSpec -> Integer
forall a. Integral a => a -> Integer
toInteger TimeSpec
tsN) (TimeSpec -> Integer
forall a. Integral a => a -> Integer
toInteger TimeSpec
tsD)

timeSpecToInt64 ∷ TimeSpec → Int64
timeSpecToInt64 :: TimeSpec -> Int64
timeSpecToInt64 (TimeSpec CTime
s CULong
ns) =

{-# LINE 172 "src/System/Posix/Clock.hsc" #-}
  let CTime s' = s in
  fromIntegral s' * nsPerSecond +

{-# LINE 183 "src/System/Posix/Clock.hsc" #-}
  fromIntegral ns
{-# INLINE timeSpecToInt64 #-}

{-# RULES
"fromIntegral/TimeSpec->Int64"  fromIntegral = timeSpecToInt64
"fromIntegral/TimeSpec->Word64" fromIntegral = fromIntegral . timeSpecToInt64
  #-}

instance Storable TimeSpec where
  alignment :: TimeSpec -> Int
alignment TimeSpec
_ = Int
8
{-# LINE 193 "src/System/Posix/Clock.hsc" #-}
  sizeOf _    = (16)
{-# LINE 194 "src/System/Posix/Clock.hsc" #-}
  peek p = TimeSpec <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 195 "src/System/Posix/Clock.hsc" #-}
                    <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 196 "src/System/Posix/Clock.hsc" #-}
  poke p (TimeSpec seconds nanoseconds) = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) p seconds
{-# LINE 198 "src/System/Posix/Clock.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) p nanoseconds
{-# LINE 199 "src/System/Posix/Clock.hsc" #-}

-- | Mirrors /clockid_t/.
newtype Clock = Clock Int32 deriving (Clock -> Clock -> Bool
(Clock -> Clock -> Bool) -> (Clock -> Clock -> Bool) -> Eq Clock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Clock -> Clock -> Bool
== :: Clock -> Clock -> Bool
$c/= :: Clock -> Clock -> Bool
/= :: Clock -> Clock -> Bool
Eq, Eq Clock
Eq Clock =>
(Clock -> Clock -> Ordering)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Bool)
-> (Clock -> Clock -> Clock)
-> (Clock -> Clock -> Clock)
-> Ord Clock
Clock -> Clock -> Bool
Clock -> Clock -> Ordering
Clock -> Clock -> Clock
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
$ccompare :: Clock -> Clock -> Ordering
compare :: Clock -> Clock -> Ordering
$c< :: Clock -> Clock -> Bool
< :: Clock -> Clock -> Bool
$c<= :: Clock -> Clock -> Bool
<= :: Clock -> Clock -> Bool
$c> :: Clock -> Clock -> Bool
> :: Clock -> Clock -> Bool
$c>= :: Clock -> Clock -> Bool
>= :: Clock -> Clock -> Bool
$cmax :: Clock -> Clock -> Clock
max :: Clock -> Clock -> Clock
$cmin :: Clock -> Clock -> Clock
min :: Clock -> Clock -> Clock
Ord, Int -> Clock -> ShowS
[Clock] -> ShowS
Clock -> String
(Int -> Clock -> ShowS)
-> (Clock -> String) -> ([Clock] -> ShowS) -> Show Clock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Clock -> ShowS
showsPrec :: Int -> Clock -> ShowS
$cshow :: Clock -> String
show :: Clock -> String
$cshowList :: [Clock] -> ShowS
showList :: [Clock] -> ShowS
Show, Ptr Clock -> IO Clock
Ptr Clock -> Int -> IO Clock
Ptr Clock -> Int -> Clock -> IO ()
Ptr Clock -> Clock -> IO ()
Clock -> Int
(Clock -> Int)
-> (Clock -> Int)
-> (Ptr Clock -> Int -> IO Clock)
-> (Ptr Clock -> Int -> Clock -> IO ())
-> (forall b. Ptr b -> Int -> IO Clock)
-> (forall b. Ptr b -> Int -> Clock -> IO ())
-> (Ptr Clock -> IO Clock)
-> (Ptr Clock -> Clock -> IO ())
-> Storable Clock
forall b. Ptr b -> Int -> IO Clock
forall b. Ptr b -> Int -> Clock -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: Clock -> Int
sizeOf :: Clock -> Int
$calignment :: Clock -> Int
alignment :: Clock -> Int
$cpeekElemOff :: Ptr Clock -> Int -> IO Clock
peekElemOff :: Ptr Clock -> Int -> IO Clock
$cpokeElemOff :: Ptr Clock -> Int -> Clock -> IO ()
pokeElemOff :: Ptr Clock -> Int -> Clock -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Clock
peekByteOff :: forall b. Ptr b -> Int -> IO Clock
$cpokeByteOff :: forall b. Ptr b -> Int -> Clock -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Clock -> IO ()
$cpeek :: Ptr Clock -> IO Clock
peek :: Ptr Clock -> IO Clock
$cpoke :: Ptr Clock -> Clock -> IO ()
poke :: Ptr Clock -> Clock -> IO ()
Storable)
{-# LINE 202 "src/System/Posix/Clock.hsc" #-}

monotonicClock  :: Clock
monotonicClock :: Clock
monotonicClock  = Int32 -> Clock
Clock Int32
1
realtimeClock  :: Clock
realtimeClock :: Clock
realtimeClock  = Int32 -> Clock
Clock Int32
0
processTimeClock  :: Clock
processTimeClock :: Clock
processTimeClock  = Int32 -> Clock
Clock Int32
2
threadTimeClock  :: Clock
threadTimeClock :: Clock
threadTimeClock  = Int32 -> Clock
Clock Int32
3

{-# LINE 209 "src/System/Posix/Clock.hsc" #-}

-- | Get the CPU-time clock of the given process.
--   See /clock_getcpuclockid(3)/.
getProcessClock ∷ MonadBase IO μ ⇒ ProcessID → μ Clock
getProcessClock :: forall (μ :: * -> *). MonadBase IO μ => ProcessID -> μ Clock
getProcessClock ProcessID
pid =
  IO Clock -> μ Clock
forall α. IO α -> μ α
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO Clock -> μ Clock) -> IO Clock -> μ Clock
forall a b. (a -> b) -> a -> b
$ (Ptr Clock -> IO Clock) -> IO Clock
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Clock -> IO Clock) -> IO Clock)
-> (Ptr Clock -> IO Clock) -> IO Clock
forall a b. (a -> b) -> a -> b
$ \Ptr Clock
p → do
    String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"getProcClock" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$ ProcessID -> Ptr Clock -> IO CInt
c_clock_getcpuclockid ProcessID
pid Ptr Clock
p
    Ptr Clock -> IO Clock
forall a. Storable a => Ptr a -> IO a
peek Ptr Clock
p

-- | Get the clock resolution. See /clock_getres(3)/.
getClockResolution ∷ MonadBase IO μ ⇒ Clock → μ TimeSpec
getClockResolution :: forall (μ :: * -> *). MonadBase IO μ => Clock -> μ TimeSpec
getClockResolution Clock
clock =
  IO TimeSpec -> μ TimeSpec
forall α. IO α -> μ α
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO TimeSpec -> μ TimeSpec) -> IO TimeSpec -> μ TimeSpec
forall a b. (a -> b) -> a -> b
$ (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec)
-> (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. (a -> b) -> a -> b
$ \Ptr TimeSpec
p → do
    String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"getClockResolution" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$ Clock -> Ptr TimeSpec -> IO CInt
c_clock_getres Clock
clock Ptr TimeSpec
p
    Ptr TimeSpec -> IO TimeSpec
forall a. Storable a => Ptr a -> IO a
peek Ptr TimeSpec
p

-- | Get the clock time. See /clock_gettime(3)/.
getClockTime ∷ MonadBase IO μ ⇒ Clock → μ TimeSpec
getClockTime :: forall (μ :: * -> *). MonadBase IO μ => Clock -> μ TimeSpec
getClockTime Clock
clock =
  IO TimeSpec -> μ TimeSpec
forall α. IO α -> μ α
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO TimeSpec -> μ TimeSpec) -> IO TimeSpec -> μ TimeSpec
forall a b. (a -> b) -> a -> b
$ (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec)
-> (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. (a -> b) -> a -> b
$ \Ptr TimeSpec
p → do
    String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"getClockTime" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$ Clock -> Ptr TimeSpec -> IO CInt
c_clock_gettime Clock
clock Ptr TimeSpec
p
    Ptr TimeSpec -> IO TimeSpec
forall a. Storable a => Ptr a -> IO a
peek Ptr TimeSpec
p

-- | Set the clock time. See /clock_settime(3)/.
setClockTime ∷ MonadBase IO μ ⇒ Clock → TimeSpec → μ ()
setClockTime :: forall (μ :: * -> *). MonadBase IO μ => Clock -> TimeSpec -> μ ()
setClockTime Clock
clock TimeSpec
ts =
  IO () -> μ ()
forall α. IO α -> μ α
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO () -> μ ()) -> IO () -> μ ()
forall a b. (a -> b) -> a -> b
$ TimeSpec -> (Ptr TimeSpec -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with TimeSpec
ts ((Ptr TimeSpec -> IO ()) -> IO ())
-> (Ptr TimeSpec -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$
    String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"setClockTime" (IO CInt -> IO ())
-> (Ptr TimeSpec -> IO CInt) -> Ptr TimeSpec -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Clock -> Ptr TimeSpec -> IO CInt
c_clock_settime Clock
clock

-- | Sleep for the specified duration. When interrupted by a signal, returns
--   the amount of time left to sleep. See /clock_nanosleep(3)/.
clockSleep ∷ MonadBase IO μ ⇒ Clock → TimeSpec → μ TimeSpec
clockSleep :: forall (μ :: * -> *).
MonadBase IO μ =>
Clock -> TimeSpec -> μ TimeSpec
clockSleep Clock
clock TimeSpec
ts =
  IO TimeSpec -> μ TimeSpec
forall α. IO α -> μ α
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO TimeSpec -> μ TimeSpec) -> IO TimeSpec -> μ TimeSpec
forall a b. (a -> b) -> a -> b
$ TimeSpec -> (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with TimeSpec
ts ((Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec)
-> (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. (a -> b) -> a -> b
$ \Ptr TimeSpec
pTs →
    (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec)
-> (Ptr TimeSpec -> IO TimeSpec) -> IO TimeSpec
forall a b. (a -> b) -> a -> b
$ \Ptr TimeSpec
pLeft → do 
      CInt
result ← Clock -> CInt -> Ptr TimeSpec -> Ptr TimeSpec -> IO CInt
c_clock_nanosleep Clock
clock CInt
0 Ptr TimeSpec
pTs Ptr TimeSpec
pLeft
      if CInt
result CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== CInt
0
        then TimeSpec -> IO TimeSpec
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TimeSpec
0
        else do
          Errno
errno ← IO Errno
getErrno
          if Errno
errno Errno -> Errno -> Bool
forall a. Eq a => a -> a -> Bool
== Errno
eINTR
            then Ptr TimeSpec -> IO TimeSpec
forall a. Storable a => Ptr a -> IO a
peek Ptr TimeSpec
pLeft
            else String -> IO TimeSpec
forall a. String -> IO a
throwErrno String
"clockSleep"

-- | Sleep until the clock time reaches the specified value.
--   See /clock_nanosleep(3)/.
clockSleepAbs ∷ MonadBase IO μ ⇒ Clock → TimeSpec → μ ()
clockSleepAbs :: forall (μ :: * -> *). MonadBase IO μ => Clock -> TimeSpec -> μ ()
clockSleepAbs Clock
clock TimeSpec
ts =
  IO () -> μ ()
forall α. IO α -> μ α
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (IO () -> μ ()) -> IO () -> μ ()
forall a b. (a -> b) -> a -> b
$ TimeSpec -> (Ptr TimeSpec -> IO ()) -> IO ()
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with TimeSpec
ts ((Ptr TimeSpec -> IO ()) -> IO ())
-> (Ptr TimeSpec -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TimeSpec
p →
    String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"clockSleepAbs" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
      Clock -> CInt -> Ptr TimeSpec -> Ptr TimeSpec -> IO CInt
c_clock_nanosleep Clock
clock CInt
1 Ptr TimeSpec
p Ptr TimeSpec
forall a. Ptr a
nullPtr
{-# LINE 260 "src/System/Posix/Clock.hsc" #-}

foreign import ccall unsafe "clock_getcpuclockid"
  c_clock_getcpuclockid ∷ ProcessID → Ptr Clock → IO CInt
foreign import ccall unsafe "clock_getres"
  c_clock_getres ∷ Clock → Ptr TimeSpec → IO CInt
foreign import ccall unsafe "clock_gettime"
  c_clock_gettime ∷ Clock → Ptr TimeSpec → IO CInt
foreign import ccall unsafe "clock_settime"
  c_clock_settime ∷ Clock → Ptr TimeSpec → IO CInt
foreign import ccall "clock_nanosleep"
  c_clock_nanosleep ∷ Clock → CInt → Ptr TimeSpec → Ptr TimeSpec → IO CInt