{-# OPTIONS_GHC -optc-D_GNU_SOURCE #-}
{-# LINE 1 "src/Linux/Epoll/Types.hsc" #-}
{-# language BangPatterns #-}
{-# language BinaryLiterals #-}
{-# language DataKinds #-}
{-# language DerivingStrategies #-}
{-# language DuplicateRecordFields #-}
{-# language GADTSyntax #-}
{-# language GeneralizedNewtypeDeriving #-}
{-# language KindSignatures #-}
{-# language MagicHash #-}
{-# language NamedFieldPuns #-}
{-# language PolyKinds #-}
{-# language ScopedTypeVariables #-}
{-# language TypeApplications #-}
{-# language DataKinds #-}
{-# language UnboxedTuples #-}

-- This is needed because hsc2hs does not currently handle ticked
-- promoted data constructors correctly.
{-# OPTIONS_GHC -fno-warn-unticked-promoted-constructors #-}





-- | All of the data constructors provided by this module are unsafe.
--   Only use them if you really know what you are doing.
module Linux.Epoll.Types
  ( EpollFlags(..)
  , ControlOperation(..)
  , Exchange(..)
  , Events(..)
  , Event(..)
  , PrimEpollData(..)
    -- * Flags
  , closeOnExec
  , add
  , modify
  , delete
    -- * Events
  , input
  , output
  , priority
  , hangup
  , readHangup
  , error
  , edgeTriggered
    -- * Events Combinators
  , containsAnyEvents
  , containsAllEvents
    -- * Marshalling
  , sizeofEvent
  , peekEventEvents
  , peekEventDataFd
  , peekEventDataPtr
  , peekEventDataU32
  , peekEventDataU64
  , pokeEventDataU64
  -- , readEventDataU64
  -- , writeEventDataU64
  ) where

import Prelude hiding (truncate,error)

import Data.Bits (Bits,(.&.),(.|.),unsafeShiftL,unsafeShiftR)
import Data.Kind (Type)
import Data.Primitive.Addr (Addr(..))
import Data.Primitive (Prim)
import Data.Primitive (indexByteArray#,writeByteArray#,readByteArray#)
import Data.Primitive (indexOffAddr#,readOffAddr#,writeOffAddr#)
import Data.Word (Word32,Word64)
import Foreign.C.Types (CInt(..))
import Foreign.Storable (Storable,peekByteOff,pokeByteOff)
import GHC.Exts (Int(I#),(+#),(*#))
import GHC.Exts (State#,Int#,Addr#,MutableByteArray#,ByteArray#)
import GHC.Ptr (Ptr(..))
import Posix.Poll (Exchange(..))
import System.Posix.Types (Fd(..))

import qualified Data.Primitive as PM

newtype ControlOperation = ControlOperation CInt
  deriving stock (ControlOperation -> ControlOperation -> Bool
(ControlOperation -> ControlOperation -> Bool)
-> (ControlOperation -> ControlOperation -> Bool)
-> Eq ControlOperation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ControlOperation -> ControlOperation -> Bool
== :: ControlOperation -> ControlOperation -> Bool
$c/= :: ControlOperation -> ControlOperation -> Bool
/= :: ControlOperation -> ControlOperation -> Bool
Eq)

newtype EpollFlags = EpollFlags CInt
  deriving stock (EpollFlags -> EpollFlags -> Bool
(EpollFlags -> EpollFlags -> Bool)
-> (EpollFlags -> EpollFlags -> Bool) -> Eq EpollFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EpollFlags -> EpollFlags -> Bool
== :: EpollFlags -> EpollFlags -> Bool
$c/= :: EpollFlags -> EpollFlags -> Bool
/= :: EpollFlags -> EpollFlags -> Bool
Eq)
  deriving newtype (Eq EpollFlags
EpollFlags
Eq EpollFlags =>
(EpollFlags -> EpollFlags -> EpollFlags)
-> (EpollFlags -> EpollFlags -> EpollFlags)
-> (EpollFlags -> EpollFlags -> EpollFlags)
-> (EpollFlags -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> EpollFlags
-> (Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> Bool)
-> (EpollFlags -> Maybe Int)
-> (EpollFlags -> Int)
-> (EpollFlags -> Bool)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int -> EpollFlags)
-> (EpollFlags -> Int)
-> Bits EpollFlags
Int -> EpollFlags
EpollFlags -> Bool
EpollFlags -> Int
EpollFlags -> Maybe Int
EpollFlags -> EpollFlags
EpollFlags -> Int -> Bool
EpollFlags -> Int -> EpollFlags
EpollFlags -> EpollFlags -> EpollFlags
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: EpollFlags -> EpollFlags -> EpollFlags
.&. :: EpollFlags -> EpollFlags -> EpollFlags
$c.|. :: EpollFlags -> EpollFlags -> EpollFlags
.|. :: EpollFlags -> EpollFlags -> EpollFlags
$cxor :: EpollFlags -> EpollFlags -> EpollFlags
xor :: EpollFlags -> EpollFlags -> EpollFlags
$ccomplement :: EpollFlags -> EpollFlags
complement :: EpollFlags -> EpollFlags
$cshift :: EpollFlags -> Int -> EpollFlags
shift :: EpollFlags -> Int -> EpollFlags
$crotate :: EpollFlags -> Int -> EpollFlags
rotate :: EpollFlags -> Int -> EpollFlags
$czeroBits :: EpollFlags
zeroBits :: EpollFlags
$cbit :: Int -> EpollFlags
bit :: Int -> EpollFlags
$csetBit :: EpollFlags -> Int -> EpollFlags
setBit :: EpollFlags -> Int -> EpollFlags
$cclearBit :: EpollFlags -> Int -> EpollFlags
clearBit :: EpollFlags -> Int -> EpollFlags
$ccomplementBit :: EpollFlags -> Int -> EpollFlags
complementBit :: EpollFlags -> Int -> EpollFlags
$ctestBit :: EpollFlags -> Int -> Bool
testBit :: EpollFlags -> Int -> Bool
$cbitSizeMaybe :: EpollFlags -> Maybe Int
bitSizeMaybe :: EpollFlags -> Maybe Int
$cbitSize :: EpollFlags -> Int
bitSize :: EpollFlags -> Int
$cisSigned :: EpollFlags -> Bool
isSigned :: EpollFlags -> Bool
$cshiftL :: EpollFlags -> Int -> EpollFlags
shiftL :: EpollFlags -> Int -> EpollFlags
$cunsafeShiftL :: EpollFlags -> Int -> EpollFlags
unsafeShiftL :: EpollFlags -> Int -> EpollFlags
$cshiftR :: EpollFlags -> Int -> EpollFlags
shiftR :: EpollFlags -> Int -> EpollFlags
$cunsafeShiftR :: EpollFlags -> Int -> EpollFlags
unsafeShiftR :: EpollFlags -> Int -> EpollFlags
$crotateL :: EpollFlags -> Int -> EpollFlags
rotateL :: EpollFlags -> Int -> EpollFlags
$crotateR :: EpollFlags -> Int -> EpollFlags
rotateR :: EpollFlags -> Int -> EpollFlags
$cpopCount :: EpollFlags -> Int
popCount :: EpollFlags -> Int
Bits)

instance Semigroup EpollFlags where <> :: EpollFlags -> EpollFlags -> EpollFlags
(<>) = EpollFlags -> EpollFlags -> EpollFlags
forall a. Bits a => a -> a -> a
(.|.)
instance Monoid EpollFlags where mempty :: EpollFlags
mempty = CInt -> EpollFlags
EpollFlags CInt
0

newtype Events :: Exchange -> Type where
  Events :: Word32 -> Events e
  deriving stock (Events a -> Events a -> Bool
(Events a -> Events a -> Bool)
-> (Events a -> Events a -> Bool) -> Eq (Events a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: Exchange). Events a -> Events a -> Bool
$c== :: forall (a :: Exchange). Events a -> Events a -> Bool
== :: Events a -> Events a -> Bool
$c/= :: forall (a :: Exchange). Events a -> Events a -> Bool
/= :: Events a -> Events a -> Bool
Eq)
  deriving newtype (Eq (Events a)
Events a
Eq (Events a) =>
(Events a -> Events a -> Events a)
-> (Events a -> Events a -> Events a)
-> (Events a -> Events a -> Events a)
-> (Events a -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> Events a
-> (Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Bool)
-> (Events a -> Maybe Int)
-> (Events a -> Int)
-> (Events a -> Bool)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int -> Events a)
-> (Events a -> Int)
-> Bits (Events a)
Int -> Events a
Events a -> Bool
Events a -> Int
Events a -> Maybe Int
Events a -> Events a
Events a -> Int -> Bool
Events a -> Int -> Events a
Events a -> Events a -> Events a
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
forall (a :: Exchange). Eq (Events a)
forall (a :: Exchange). Events a
forall (a :: Exchange). Int -> Events a
forall (a :: Exchange). Events a -> Bool
forall (a :: Exchange). Events a -> Int
forall (a :: Exchange). Events a -> Maybe Int
forall (a :: Exchange). Events a -> Events a
forall (a :: Exchange). Events a -> Int -> Bool
forall (a :: Exchange). Events a -> Int -> Events a
forall (a :: Exchange). Events a -> Events a -> Events a
$c.&. :: forall (a :: Exchange). Events a -> Events a -> Events a
.&. :: Events a -> Events a -> Events a
$c.|. :: forall (a :: Exchange). Events a -> Events a -> Events a
.|. :: Events a -> Events a -> Events a
$cxor :: forall (a :: Exchange). Events a -> Events a -> Events a
xor :: Events a -> Events a -> Events a
$ccomplement :: forall (a :: Exchange). Events a -> Events a
complement :: Events a -> Events a
$cshift :: forall (a :: Exchange). Events a -> Int -> Events a
shift :: Events a -> Int -> Events a
$crotate :: forall (a :: Exchange). Events a -> Int -> Events a
rotate :: Events a -> Int -> Events a
$czeroBits :: forall (a :: Exchange). Events a
zeroBits :: Events a
$cbit :: forall (a :: Exchange). Int -> Events a
bit :: Int -> Events a
$csetBit :: forall (a :: Exchange). Events a -> Int -> Events a
setBit :: Events a -> Int -> Events a
$cclearBit :: forall (a :: Exchange). Events a -> Int -> Events a
clearBit :: Events a -> Int -> Events a
$ccomplementBit :: forall (a :: Exchange). Events a -> Int -> Events a
complementBit :: Events a -> Int -> Events a
$ctestBit :: forall (a :: Exchange). Events a -> Int -> Bool
testBit :: Events a -> Int -> Bool
$cbitSizeMaybe :: forall (a :: Exchange). Events a -> Maybe Int
bitSizeMaybe :: Events a -> Maybe Int
$cbitSize :: forall (a :: Exchange). Events a -> Int
bitSize :: Events a -> Int
$cisSigned :: forall (a :: Exchange). Events a -> Bool
isSigned :: Events a -> Bool
$cshiftL :: forall (a :: Exchange). Events a -> Int -> Events a
shiftL :: Events a -> Int -> Events a
$cunsafeShiftL :: forall (a :: Exchange). Events a -> Int -> Events a
unsafeShiftL :: Events a -> Int -> Events a
$cshiftR :: forall (a :: Exchange). Events a -> Int -> Events a
shiftR :: Events a -> Int -> Events a
$cunsafeShiftR :: forall (a :: Exchange). Events a -> Int -> Events a
unsafeShiftR :: Events a -> Int -> Events a
$crotateL :: forall (a :: Exchange). Events a -> Int -> Events a
rotateL :: Events a -> Int -> Events a
$crotateR :: forall (a :: Exchange). Events a -> Int -> Events a
rotateR :: Events a -> Int -> Events a
$cpopCount :: forall (a :: Exchange). Events a -> Int
popCount :: Events a -> Int
Bits,Ptr (Events a) -> IO (Events a)
Ptr (Events a) -> Int -> IO (Events a)
Ptr (Events a) -> Int -> Events a -> IO ()
Ptr (Events a) -> Events a -> IO ()
Events a -> Int
(Events a -> Int)
-> (Events a -> Int)
-> (Ptr (Events a) -> Int -> IO (Events a))
-> (Ptr (Events a) -> Int -> Events a -> IO ())
-> (forall b. Ptr b -> Int -> IO (Events a))
-> (forall b. Ptr b -> Int -> Events a -> IO ())
-> (Ptr (Events a) -> IO (Events a))
-> (Ptr (Events a) -> Events a -> IO ())
-> Storable (Events a)
forall b. Ptr b -> Int -> IO (Events a)
forall b. Ptr b -> Int -> Events a -> 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
forall (a :: Exchange). Ptr (Events a) -> IO (Events a)
forall (a :: Exchange). Ptr (Events a) -> Int -> IO (Events a)
forall (a :: Exchange). Ptr (Events a) -> Int -> Events a -> IO ()
forall (a :: Exchange). Ptr (Events a) -> Events a -> IO ()
forall (a :: Exchange). Events a -> Int
forall (a :: Exchange) b. Ptr b -> Int -> IO (Events a)
forall (a :: Exchange) b. Ptr b -> Int -> Events a -> IO ()
$csizeOf :: forall (a :: Exchange). Events a -> Int
sizeOf :: Events a -> Int
$calignment :: forall (a :: Exchange). Events a -> Int
alignment :: Events a -> Int
$cpeekElemOff :: forall (a :: Exchange). Ptr (Events a) -> Int -> IO (Events a)
peekElemOff :: Ptr (Events a) -> Int -> IO (Events a)
$cpokeElemOff :: forall (a :: Exchange). Ptr (Events a) -> Int -> Events a -> IO ()
pokeElemOff :: Ptr (Events a) -> Int -> Events a -> IO ()
$cpeekByteOff :: forall (a :: Exchange) b. Ptr b -> Int -> IO (Events a)
peekByteOff :: forall b. Ptr b -> Int -> IO (Events a)
$cpokeByteOff :: forall (a :: Exchange) b. Ptr b -> Int -> Events a -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Events a -> IO ()
$cpeek :: forall (a :: Exchange). Ptr (Events a) -> IO (Events a)
peek :: Ptr (Events a) -> IO (Events a)
$cpoke :: forall (a :: Exchange). Ptr (Events a) -> Events a -> IO ()
poke :: Ptr (Events a) -> Events a -> IO ()
Storable,Addr# -> Int# -> Events a
ByteArray# -> Int# -> Events a
Proxy (Events a) -> Int#
Events a -> Int#
(Proxy (Events a) -> Int#)
-> (Events a -> Int#)
-> (Proxy (Events a) -> Int#)
-> (Events a -> Int#)
-> (ByteArray# -> Int# -> Events a)
-> (forall s.
    MutableByteArray# s
    -> Int# -> State# s -> (# State# s, Events a #))
-> (forall s.
    MutableByteArray# s -> Int# -> Events a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Events a -> State# s -> State# s)
-> (Addr# -> Int# -> Events a)
-> (forall s.
    Addr# -> Int# -> State# s -> (# State# s, Events a #))
-> (forall s. Addr# -> Int# -> Events a -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Events a -> State# s -> State# s)
-> Prim (Events a)
forall s. Addr# -> Int# -> Int# -> Events a -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Events a #)
forall s. Addr# -> Int# -> Events a -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Events a -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Events a #)
forall s.
MutableByteArray# s -> Int# -> Events a -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
forall (a :: Exchange). Addr# -> Int# -> Events a
forall (a :: Exchange). ByteArray# -> Int# -> Events a
forall (a :: Exchange). Proxy (Events a) -> Int#
forall (a :: Exchange). Events a -> Int#
forall (a :: Exchange) s.
Addr# -> Int# -> Int# -> Events a -> State# s -> State# s
forall (a :: Exchange) s.
Addr# -> Int# -> State# s -> (# State# s, Events a #)
forall (a :: Exchange) s.
Addr# -> Int# -> Events a -> State# s -> State# s
forall (a :: Exchange) s.
MutableByteArray# s
-> Int# -> Int# -> Events a -> State# s -> State# s
forall (a :: Exchange) s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Events a #)
forall (a :: Exchange) s.
MutableByteArray# s -> Int# -> Events a -> State# s -> State# s
$csizeOfType# :: forall (a :: Exchange). Proxy (Events a) -> Int#
sizeOfType# :: Proxy (Events a) -> Int#
$csizeOf# :: forall (a :: Exchange). Events a -> Int#
sizeOf# :: Events a -> Int#
$calignmentOfType# :: forall (a :: Exchange). Proxy (Events a) -> Int#
alignmentOfType# :: Proxy (Events a) -> Int#
$calignment# :: forall (a :: Exchange). Events a -> Int#
alignment# :: Events a -> Int#
$cindexByteArray# :: forall (a :: Exchange). ByteArray# -> Int# -> Events a
indexByteArray# :: ByteArray# -> Int# -> Events a
$creadByteArray# :: forall (a :: Exchange) s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Events a #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Events a #)
$cwriteByteArray# :: forall (a :: Exchange) s.
MutableByteArray# s -> Int# -> Events a -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Events a -> State# s -> State# s
$csetByteArray# :: forall (a :: Exchange) s.
MutableByteArray# s
-> Int# -> Int# -> Events a -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Events a -> State# s -> State# s
$cindexOffAddr# :: forall (a :: Exchange). Addr# -> Int# -> Events a
indexOffAddr# :: Addr# -> Int# -> Events a
$creadOffAddr# :: forall (a :: Exchange) s.
Addr# -> Int# -> State# s -> (# State# s, Events a #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Events a #)
$cwriteOffAddr# :: forall (a :: Exchange) s.
Addr# -> Int# -> Events a -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Events a -> State# s -> State# s
$csetOffAddr# :: forall (a :: Exchange) s.
Addr# -> Int# -> Int# -> Events a -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Events a -> State# s -> State# s
Prim)

instance Semigroup (Events e) where <> :: Events e -> Events e -> Events e
(<>) = Events e -> Events e -> Events e
forall a. Bits a => a -> a -> a
(.|.)
instance Monoid (Events e) where mempty :: Events e
mempty = Word32 -> Events e
forall (e :: Exchange). Word32 -> Events e
Events Word32
0

-- | A data type corresponding to @struct epoll_event@. Linux
-- defines this as:
--
-- > typedef union epoll_data {
-- >     void    *ptr;
-- >     int      fd;
-- >     uint32_t u32;
-- >     uint64_t u64;
-- > } epoll_data_t;
-- >
-- > struct epoll_event {
-- >     uint32_t     events; /* Epoll events */
-- >     epoll_data_t data;   /* User data variable */
-- > };
--
-- It is a little difficult to capture what this type conveys, but
-- we make an attempt. The second argument to the @Event@ type
-- constructor is either @Addr@, @Fd@, @Word32@, or @Word64@. This
-- corresponds to the four possibilities in the @epoll_data@ union
-- type. As long as the user monomorphizes this type when using
-- it, there should not be any performance penalty for the
-- flexibility afforded by this approach.
data Event :: Exchange -> Type -> Type where
  Event ::
    { forall (e :: Exchange) a. Event e a -> Events e
events :: !(Events e)
      -- ^ Epoll events
    , forall (e :: Exchange) a. Event e a -> a
payload :: !a
      -- ^ User data variable, named @data@ in @struct epoll_event@.
    } -> Event e a

class PrimEpollData a where
  indexByteArrayEpoll :: ByteArray# -> Int# -> Event e a
  readByteArrayEpoll :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Event e a #)
  writeByteArrayEpoll :: MutableByteArray# s -> Int# -> Event e a -> State# s -> State# s
  indexOffAddrEpoll :: Addr# -> Int# -> Event e a
  readOffAddrEpoll :: Addr# -> Int# -> State# s -> (# State# s, Event e a #)
  writeOffAddrEpoll :: Addr# -> Int# -> Event e a -> State# s -> State# s

instance PrimEpollData a => Prim (Event e a) where
  {-# inline sizeOf# #-}
  {-# inline alignment# #-}
  {-# inline indexByteArray# #-}
  {-# inline readByteArray# #-}
  {-# inline writeByteArray# #-}
  {-# inline setByteArray# #-}
  {-# inline indexOffAddr# #-}
  {-# inline readOffAddr# #-}
  {-# inline writeOffAddr# #-}
  {-# inline setOffAddr# #-}
  sizeOf# :: Event e a -> Int#
sizeOf# Event e a
_ = Int -> Int#
unI (Int
12)
{-# LINE 149 "src/Linux/Epoll/Types.hsc" #-}
  alignment# _ = PM.alignment# (undefined :: Word32)
  indexByteArray# :: ByteArray# -> Int# -> Event e a
indexByteArray# = ByteArray# -> Int# -> Event e a
forall a (e :: Exchange).
PrimEpollData a =>
ByteArray# -> Int# -> Event e a
forall (e :: Exchange). ByteArray# -> Int# -> Event e a
indexByteArrayEpoll
  readByteArray# :: forall s.
MutableByteArray# s
-> Int# -> State# s -> (# State# s, Event e a #)
readByteArray# = MutableByteArray# s
-> Int# -> State# s -> (# State# s, Event e a #)
forall a s (e :: Exchange).
PrimEpollData a =>
MutableByteArray# s
-> Int# -> State# s -> (# State# s, Event e a #)
forall s (e :: Exchange).
MutableByteArray# s
-> Int# -> State# s -> (# State# s, Event e a #)
readByteArrayEpoll
  writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Event e a -> State# s -> State# s
writeByteArray# = MutableByteArray# s -> Int# -> Event e a -> State# s -> State# s
forall a s (e :: Exchange).
PrimEpollData a =>
MutableByteArray# s -> Int# -> Event e a -> State# s -> State# s
forall s (e :: Exchange).
MutableByteArray# s -> Int# -> Event e a -> State# s -> State# s
writeByteArrayEpoll
  setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Event e a -> State# s -> State# s
setByteArray# = MutableByteArray# s
-> Int# -> Int# -> Event e a -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s
PM.defaultSetByteArray#
  indexOffAddr# :: Addr# -> Int# -> Event e a
indexOffAddr# = Addr# -> Int# -> Event e a
forall a (e :: Exchange).
PrimEpollData a =>
Addr# -> Int# -> Event e a
forall (e :: Exchange). Addr# -> Int# -> Event e a
indexOffAddrEpoll
  readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Event e a #)
readOffAddr# = Addr# -> Int# -> State# s -> (# State# s, Event e a #)
forall a s (e :: Exchange).
PrimEpollData a =>
Addr# -> Int# -> State# s -> (# State# s, Event e a #)
forall s (e :: Exchange).
Addr# -> Int# -> State# s -> (# State# s, Event e a #)
readOffAddrEpoll
  writeOffAddr# :: forall s. Addr# -> Int# -> Event e a -> State# s -> State# s
writeOffAddr# = Addr# -> Int# -> Event e a -> State# s -> State# s
forall a (e :: Exchange) s.
PrimEpollData a =>
Addr# -> Int# -> Event e a -> State# s -> State# s
forall (e :: Exchange) s.
Addr# -> Int# -> Event e a -> State# s -> State# s
writeOffAddrEpoll
  setOffAddr# :: forall s.
Addr# -> Int# -> Int# -> Event e a -> State# s -> State# s
setOffAddr# = Addr# -> Int# -> Int# -> Event e a -> State# s -> State# s
forall a s.
Prim a =>
Addr# -> Int# -> Int# -> a -> State# s -> State# s
PM.defaultSetOffAddr#

instance PrimEpollData Fd where
  {-# inline indexByteArrayEpoll #-}
  {-# inline readByteArrayEpoll #-}
  {-# inline writeByteArrayEpoll #-}
  {-# inline indexOffAddrEpoll #-}
  {-# inline readOffAddrEpoll #-}
  {-# inline writeOffAddrEpoll #-}
  indexByteArrayEpoll :: forall (e :: Exchange). ByteArray# -> Int# -> Event e Fd
indexByteArrayEpoll ByteArray#
arr Int#
i = Event
    { $sel:events:Event :: Events e
events = (\ByteArray#
hsc_arr Int#
hsc_ix -> ByteArray# -> Int# -> Events e
forall a. Prim a => ByteArray# -> Int# -> a
indexByteArray# ByteArray#
hsc_arr (Int#
0# Int# -> Int# -> Int#
+# (Int#
hsc_ix Int# -> Int# -> Int#
*# Int#
3#))) ByteArray#
arr Int#
i
{-# LINE 168 "src/Linux/Epoll/Types.hsc" #-}
    , payload = (\hsc_arr hsc_ix -> indexByteArray# hsc_arr (1# +# (hsc_ix *# 3#))) arr i
{-# LINE 169 "src/Linux/Epoll/Types.hsc" #-}
    }
  writeByteArrayEpoll :: forall s (e :: Exchange).
MutableByteArray# s -> Int# -> Event e Fd -> State# s -> State# s
writeByteArrayEpoll MutableByteArray# s
arr Int#
i Event{Events e
$sel:events:Event :: forall (e :: Exchange) a. Event e a -> Events e
events :: Events e
events,Fd
$sel:payload:Event :: forall (e :: Exchange) a. Event e a -> a
payload :: Fd
payload} State# s
s0 =
    case (\MutableByteArray# s
hsc_arr Int#
hsc_ix -> MutableByteArray# s -> Int# -> Events e -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> Events e -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteArray# MutableByteArray# s
hsc_arr (Int#
0# Int# -> Int# -> Int#
+# (Int#
hsc_ix Int# -> Int# -> Int#
*# Int#
3#))) MutableByteArray# s
arr Int#
i Events e
events State# s
s0 of
{-# LINE 172 "src/Linux/Epoll/Types.hsc" #-}
      s1 -> (\hsc_arr hsc_ix -> writeByteArray# hsc_arr (1# +# (hsc_ix *# 3#))) arr i payload s1
{-# LINE 173 "src/Linux/Epoll/Types.hsc" #-}
  readByteArrayEpoll arr i s0 =
    case (\hsc_arr hsc_ix -> readByteArray# hsc_arr (0# +# (hsc_ix *# 3#))) arr i s0 of
{-# LINE 175 "src/Linux/Epoll/Types.hsc" #-}
      (# s1, events #) -> case (\hsc_arr hsc_ix -> readByteArray# hsc_arr (1# +# (hsc_ix *# 3#))) arr i s1 of
{-# LINE 176 "src/Linux/Epoll/Types.hsc" #-}
        (# s2, payload #) -> (# s2, Event{events,payload} #)
  indexOffAddrEpoll :: forall (e :: Exchange). Addr# -> Int# -> Event e Fd
indexOffAddrEpoll Addr#
arr Int#
i = Event
    { $sel:events:Event :: Events e
events = (\Addr#
hsc_arr Int#
hsc_ix -> Addr# -> Int# -> Events e
forall a. Prim a => Addr# -> Int# -> a
indexOffAddr# Addr#
hsc_arr (Int#
0# Int# -> Int# -> Int#
+# (Int#
hsc_ix Int# -> Int# -> Int#
*# Int#
3#))) Addr#
arr Int#
i
{-# LINE 179 "src/Linux/Epoll/Types.hsc" #-}
    , payload = (\hsc_arr hsc_ix -> indexOffAddr# hsc_arr (1# +# (hsc_ix *# 3#))) arr i
{-# LINE 180 "src/Linux/Epoll/Types.hsc" #-}
    }
  writeOffAddrEpoll :: forall (e :: Exchange) s.
Addr# -> Int# -> Event e Fd -> State# s -> State# s
writeOffAddrEpoll Addr#
arr Int#
i Event{Events e
$sel:events:Event :: forall (e :: Exchange) a. Event e a -> Events e
events :: Events e
events,Fd
$sel:payload:Event :: forall (e :: Exchange) a. Event e a -> a
payload :: Fd
payload} State# s
s0 =
    case (\Addr#
hsc_arr Int#
hsc_ix -> Addr# -> Int# -> Events e -> State# s -> State# s
forall s. Addr# -> Int# -> Events e -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# Addr#
hsc_arr (Int#
0# Int# -> Int# -> Int#
+# (Int#
hsc_ix Int# -> Int# -> Int#
*# Int#
3#))) Addr#
arr Int#
i Events e
events State# s
s0 of
{-# LINE 183 "src/Linux/Epoll/Types.hsc" #-}
      s1 -> (\hsc_arr hsc_ix -> writeOffAddr# hsc_arr (1# +# (hsc_ix *# 3#))) arr i payload s1
{-# LINE 184 "src/Linux/Epoll/Types.hsc" #-}
  readOffAddrEpoll arr i s0 =
    case (\hsc_arr hsc_ix -> readOffAddr# hsc_arr (0# +# (hsc_ix *# 3#))) arr i s0 of
{-# LINE 186 "src/Linux/Epoll/Types.hsc" #-}
      (# s1, events #) -> case (\hsc_arr hsc_ix -> readOffAddr# hsc_arr (1# +# (hsc_ix *# 3#))) arr i s1 of
{-# LINE 187 "src/Linux/Epoll/Types.hsc" #-}
        (# s2, payload #) -> (# s2, Event{events,payload} #)

-- | Since @epoll_event@ includes an unaligned 64-bit word, it is
-- difficult to use @hsc2hs@ to generate the marshalling code. Consequently,
-- the offsets of @events@ and @data@ are currently hardcoded. Open an
-- issue in this causes a problem on your platform.
instance PrimEpollData Word64 where
  {-# inline indexByteArrayEpoll #-}
  {-# inline readByteArrayEpoll #-}
  {-# inline writeByteArrayEpoll #-}
  {-# inline indexOffAddrEpoll #-}
  {-# inline readOffAddrEpoll #-}
  {-# inline writeOffAddrEpoll #-}
  indexByteArrayEpoll :: forall (e :: Exchange). ByteArray# -> Int# -> Event e Word64
indexByteArrayEpoll ByteArray#
arr Int#
i = Event
    { $sel:events:Event :: Events e
events = ByteArray# -> Int# -> Events e
forall a. Prim a => ByteArray# -> Int# -> a
PM.indexByteArray# ByteArray#
arr (Int#
i Int# -> Int# -> Int#
*# Int#
3#)
    , $sel:payload:Event :: Word64
payload = Word32 -> Word32 -> Word64
composePayload
        (ByteArray# -> Int# -> Word32
forall a. Prim a => ByteArray# -> Int# -> a
PM.indexByteArray# ByteArray#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
1#))
        (ByteArray# -> Int# -> Word32
forall a. Prim a => ByteArray# -> Int# -> a
PM.indexByteArray# ByteArray#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
2#))
    }
  writeByteArrayEpoll :: forall s (e :: Exchange).
MutableByteArray# s
-> Int# -> Event e Word64 -> State# s -> State# s
writeByteArrayEpoll MutableByteArray# s
arr Int#
i Event{Events e
$sel:events:Event :: forall (e :: Exchange) a. Event e a -> Events e
events :: Events e
events,Word64
$sel:payload:Event :: forall (e :: Exchange) a. Event e a -> a
payload :: Word64
payload} State# s
s0 = case MutableByteArray# s -> Int# -> Events e -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> Events e -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
PM.writeByteArray# MutableByteArray# s
arr (Int#
i Int# -> Int# -> Int#
*# Int#
3#) Events e
events State# s
s0 of
    State# s
s1 -> case MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
PM.writeByteArray# MutableByteArray# s
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
1#) Word32
pa State# s
s1 of
      State# s
s2 -> MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
PM.writeByteArray# MutableByteArray# s
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
2#) Word32
pb State# s
s2
    where
    !(Word32
pa,Word32
pb) = Word64 -> (Word32, Word32)
decomposePayload Word64
payload
  readByteArrayEpoll :: forall s (e :: Exchange).
MutableByteArray# s
-> Int# -> State# s -> (# State# s, Event e Word64 #)
readByteArrayEpoll MutableByteArray# s
arr Int#
i State# s
s0 = case MutableByteArray# s -> Int# -> State# s -> (# State# s, Events e #)
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Events e #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
PM.readByteArray# MutableByteArray# s
arr (Int#
i Int# -> Int# -> Int#
*# Int#
3#) State# s
s0 of
    (# State# s
s1, Events e
events #) -> case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32 #)
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32 #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
PM.readByteArray# MutableByteArray# s
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
1#) State# s
s1 of
      (# State# s
s2, Word32
pa #) -> case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32 #)
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32 #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
PM.readByteArray# MutableByteArray# s
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
2#) State# s
s2 of
        (# State# s
s3, Word32
pb #) -> let payload :: Word64
payload = Word32 -> Word32 -> Word64
composePayload Word32
pa Word32
pb in
          (# State# s
s3, Event{Events e
$sel:events:Event :: Events e
events :: Events e
events,Word64
$sel:payload:Event :: Word64
payload :: Word64
payload} #)
  indexOffAddrEpoll :: forall (e :: Exchange). Addr# -> Int# -> Event e Word64
indexOffAddrEpoll Addr#
arr Int#
i = Event
    { $sel:events:Event :: Events e
events = Addr# -> Int# -> Events e
forall a. Prim a => Addr# -> Int# -> a
PM.indexOffAddr# Addr#
arr (Int#
i Int# -> Int# -> Int#
*# Int#
3#)
    , $sel:payload:Event :: Word64
payload = Word32 -> Word32 -> Word64
composePayload
        (Addr# -> Int# -> Word32
forall a. Prim a => Addr# -> Int# -> a
PM.indexOffAddr# Addr#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
1#))
        (Addr# -> Int# -> Word32
forall a. Prim a => Addr# -> Int# -> a
PM.indexOffAddr# Addr#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
2#))
    }
  writeOffAddrEpoll :: forall (e :: Exchange) s.
Addr# -> Int# -> Event e Word64 -> State# s -> State# s
writeOffAddrEpoll Addr#
arr Int#
i Event{Events e
$sel:events:Event :: forall (e :: Exchange) a. Event e a -> Events e
events :: Events e
events,Word64
$sel:payload:Event :: forall (e :: Exchange) a. Event e a -> a
payload :: Word64
payload} State# s
s0 = case Addr# -> Int# -> Events e -> State# s -> State# s
forall s. Addr# -> Int# -> Events e -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
PM.writeOffAddr# Addr#
arr (Int#
i Int# -> Int# -> Int#
*# Int#
3#) Events e
events State# s
s0 of
    State# s
s1 -> case Addr# -> Int# -> Word32 -> State# s -> State# s
forall s. Addr# -> Int# -> Word32 -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
PM.writeOffAddr# Addr#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
1#) Word32
pa State# s
s1 of
      State# s
s2 -> Addr# -> Int# -> Word32 -> State# s -> State# s
forall s. Addr# -> Int# -> Word32 -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
PM.writeOffAddr# Addr#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
2#) Word32
pb State# s
s2
    where
    !(Word32
pa,Word32
pb) = Word64 -> (Word32, Word32)
decomposePayload Word64
payload
  readOffAddrEpoll :: forall s (e :: Exchange).
Addr# -> Int# -> State# s -> (# State# s, Event e Word64 #)
readOffAddrEpoll Addr#
arr Int#
i State# s
s0 = case Addr# -> Int# -> State# s -> (# State# s, Events e #)
forall s. Addr# -> Int# -> State# s -> (# State# s, Events e #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
PM.readOffAddr# Addr#
arr (Int#
i Int# -> Int# -> Int#
*# Int#
3#) State# s
s0 of
    (# State# s
s1, Events e
events #) -> case Addr# -> Int# -> State# s -> (# State# s, Word32 #)
forall s. Addr# -> Int# -> State# s -> (# State# s, Word32 #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
PM.readOffAddr# Addr#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
1#) State# s
s1 of
      (# State# s
s2, Word32
pa #) -> case Addr# -> Int# -> State# s -> (# State# s, Word32 #)
forall s. Addr# -> Int# -> State# s -> (# State# s, Word32 #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
PM.readOffAddr# Addr#
arr ((Int#
i Int# -> Int# -> Int#
*# Int#
3#) Int# -> Int# -> Int#
+# Int#
2#) State# s
s2 of
        (# State# s
s3, Word32
pb #) -> let payload :: Word64
payload = Word32 -> Word32 -> Word64
composePayload Word32
pa Word32
pb in
          (# State# s
s3, Event{Events e
$sel:events:Event :: Events e
events :: Events e
events,Word64
$sel:payload:Event :: Word64
payload :: Word64
payload} #)

-- | The @EPOLL_CTL_ADD@ control operation.
add :: ControlOperation
add :: ControlOperation
add = CInt -> ControlOperation
ControlOperation CInt
1
{-# LINE 236 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLL_CTL_MOD@ control operation.
modify :: ControlOperation
modify :: ControlOperation
modify = CInt -> ControlOperation
ControlOperation CInt
3
{-# LINE 240 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLL_CTL_DEL@ control operation.
delete :: ControlOperation
delete :: ControlOperation
delete = CInt -> ControlOperation
ControlOperation CInt
2
{-# LINE 244 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLL_CLOEXEC@ flag.
closeOnExec :: EpollFlags
closeOnExec :: EpollFlags
closeOnExec = CInt -> EpollFlags
EpollFlags CInt
524288
{-# LINE 248 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLLIN@ event. Can appear in a request or a response.
input :: Events e
input :: forall (a :: Exchange). Events a
input = Word32 -> Events e
forall (e :: Exchange). Word32 -> Events e
Events Word32
1
{-# LINE 252 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLLOUT@ event. Can appear in a request or a response.
output :: Events e
output :: forall (a :: Exchange). Events a
output = Word32 -> Events e
forall (e :: Exchange). Word32 -> Events e
Events Word32
4
{-# LINE 256 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLLPRI@ event. Can appear in a request or a response.
priority :: Events e
priority :: forall (a :: Exchange). Events a
priority = Word32 -> Events e
forall (e :: Exchange). Word32 -> Events e
Events Word32
2
{-# LINE 260 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLLERR@ event. The
-- <http://man7.org/linux/man-pages/man2/epoll_ctl.2.html epoll_ctl documentation> says
-- "@epoll_wait@ will always wait for this event; it is not necessary to set it in @events@".
-- Consequently, in this library, it has been marked as only appearing in @Response@ positions.
error :: Events Response
error :: Events 'Response
error = Word32 -> Events 'Response
forall (e :: Exchange). Word32 -> Events e
Events Word32
8
{-# LINE 267 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLLHUP@ event. The
-- <http://man7.org/linux/man-pages/man2/epoll_ctl.2.html epoll_ctl documentation> says
-- "@epoll_wait@ will always wait for this event; it is not necessary to set it in @events@".
-- Consequently, in this library, it has been marked as only appearing in @Response@ positions.
hangup :: Events Response
hangup :: Events 'Response
hangup = Word32 -> Events 'Response
forall (e :: Exchange). Word32 -> Events e
Events Word32
16
{-# LINE 274 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLLRDHUP@ event. Can appear in a request or a response.
readHangup :: Events e
readHangup :: forall (a :: Exchange). Events a
readHangup = Word32 -> Events e
forall (e :: Exchange). Word32 -> Events e
Events Word32
8192
{-# LINE 278 "src/Linux/Epoll/Types.hsc" #-}

-- | The @EPOLLET@ event. Only appears in requests.
edgeTriggered :: Events Request
edgeTriggered :: Events 'Request
edgeTriggered = Word32 -> Events 'Request
forall (e :: Exchange). Word32 -> Events e
Events Word32
2147483648
{-# LINE 282 "src/Linux/Epoll/Types.hsc" #-}

-- | Does the first event set entirely contain the second one? That is,
-- is the second argument a subset of the first?
containsAllEvents :: Events e -> Events e -> Bool
containsAllEvents :: forall (a :: Exchange). Events a -> Events a -> Bool
containsAllEvents (Events Word32
a) (Events Word32
b) = Word32
a Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32
b Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
b

-- | Does the first event set contain any of the events from the second one?
containsAnyEvents :: Events e -> Events e -> Bool
containsAnyEvents :: forall (a :: Exchange). Events a -> Events a -> Bool
containsAnyEvents (Events Word32
a) (Events Word32
b) = (Word32
a Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32
b) Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
0

sizeofEvent :: Int
sizeofEvent :: Int
sizeofEvent = (Int
12)
{-# LINE 294 "src/Linux/Epoll/Types.hsc" #-}

-- | Read @events@ from @struct epoll_event@.
peekEventEvents :: Addr -> IO (Events e)
peekEventEvents :: forall (e :: Exchange). Addr -> IO (Events e)
peekEventEvents (Addr Addr#
p) = (\Ptr Any
hsc_ptr -> Ptr Any -> Int -> IO (Events e)
forall b. Ptr b -> Int -> IO (Events e)
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Any
hsc_ptr Int
0) (Addr# -> Ptr Any
forall a. Addr# -> Ptr a
Ptr Addr#
p)
{-# LINE 298 "src/Linux/Epoll/Types.hsc" #-}

-- | Read @data.fd@ from @struct epoll_event@.
peekEventDataFd :: Addr -> IO Fd
peekEventDataFd :: Addr -> IO Fd
peekEventDataFd (Addr Addr#
p) = (\Ptr Any
hsc_ptr -> Ptr Any -> Int -> IO Fd
forall b. Ptr b -> Int -> IO Fd
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Any
hsc_ptr Int
4) (Addr# -> Ptr Any
forall a. Addr# -> Ptr a
Ptr Addr#
p)
{-# LINE 302 "src/Linux/Epoll/Types.hsc" #-}

-- | Read @data.ptr@ from @struct epoll_event@.
peekEventDataPtr :: Addr -> IO Addr
peekEventDataPtr :: Addr -> IO Addr
peekEventDataPtr (Addr Addr#
p) = do
  Ptr Addr#
q <- (\Ptr Any
hsc_ptr -> Ptr Any -> Int -> IO (Ptr Any)
forall b. Ptr b -> Int -> IO (Ptr Any)
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Any
hsc_ptr Int
4) (Addr# -> Ptr Any
forall a. Addr# -> Ptr a
Ptr Addr#
p)
{-# LINE 307 "src/Linux/Epoll/Types.hsc" #-}
  pure (Addr q)

-- | Read @data.u32@ from @struct epoll_event@.
peekEventDataU32 :: Addr -> IO Word32
peekEventDataU32 :: Addr -> IO Word32
peekEventDataU32 (Addr Addr#
p) = (\Ptr Any
hsc_ptr -> Ptr Any -> Int -> IO Word32
forall b. Ptr b -> Int -> IO Word32
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Any
hsc_ptr Int
4) (Addr# -> Ptr Any
forall a. Addr# -> Ptr a
Ptr Addr#
p)
{-# LINE 312 "src/Linux/Epoll/Types.hsc" #-}

-- | Read @data.u64@ from @struct epoll_event@.
peekEventDataU64 :: Addr -> IO Word64
peekEventDataU64 :: Addr -> IO Word64
peekEventDataU64 (Addr Addr#
p) = (\Ptr Any
hsc_ptr -> Ptr Any -> Int -> IO Word64
forall b. Ptr b -> Int -> IO Word64
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Any
hsc_ptr Int
4) (Addr# -> Ptr Any
forall a. Addr# -> Ptr a
Ptr Addr#
p)
{-# LINE 316 "src/Linux/Epoll/Types.hsc" #-}

-- | Write @data.u64@ from @struct epoll_event@.
pokeEventDataU64 :: Addr -> Word64 -> IO ()
pokeEventDataU64 :: Addr -> Word64 -> IO ()
pokeEventDataU64 (Addr Addr#
p) Word64
w = (\Ptr Any
hsc_ptr -> Ptr Any -> Int -> Word64 -> IO ()
forall b. Ptr b -> Int -> Word64 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Any
hsc_ptr Int
4) (Addr# -> Ptr Any
forall a. Addr# -> Ptr a
Ptr Addr#
p) Word64
w
{-# LINE 320 "src/Linux/Epoll/Types.hsc" #-}

composePayload :: Word32 -> Word32 -> Word64
{-# inline composePayload #-}
composePayload :: Word32 -> Word32 -> Word64
composePayload Word32
a Word32
b = Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
unsafeShiftL (Word32 -> Word64
word32ToWord64 Word32
a) Int
32 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word32 -> Word64
word32ToWord64 Word32
b

decomposePayload :: Word64 -> (Word32,Word32)
{-# inline decomposePayload #-}
decomposePayload :: Word64 -> (Word32, Word32)
decomposePayload Word64
w = (Word64 -> Word32
word64ToWord32 (Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
unsafeShiftR Word64
w Int
32), Word64 -> Word32
word64ToWord32 Word64
w)

word32ToWord64 :: Word32 -> Word64
word32ToWord64 :: Word32 -> Word64
word32ToWord64 = Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral

word64ToWord32 :: Word64 -> Word32
word64ToWord32 :: Word64 -> Word32
word64ToWord32 = Word64 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral

unI :: Int -> Int#
unI :: Int -> Int#
unI (I# Int#
i) = Int#
i