{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE RoleAnnotations            #-}
module Foreign.SharedPtr.C
  ( SharedPtr (), Allocator, AllocatorT

  , c'shared_createAllocator, c'shared_lookupAllocator
  , c'shared_destroyAllocator, c'shared_getStoreName
  , c'shared_ptrToShPtr, c'shared_shPtrToPtr
  , c'shared_malloc, c'shared_realloc, c'shared_free

  , p'shared_createAllocator, p'shared_lookupAllocator
  , p'shared_destroyAllocator, p'shared_getStoreName
  , p'shared_ptrToShPtr, p'shared_shPtrToPtr
  , p'shared_malloc, p'shared_realloc, p'shared_free

  , p'vk_shared_malloc, p'vk_shared_realloc, p'vk_shared_free
  ) where

import           Data.Data        (Data)
import           Data.Void        (Void)
import           Foreign.C.String
import           Foreign.C.Types
import           Foreign.Ptr
import           Foreign.Storable
import           GHC.Generics     (Generic)

type role SharedPtr phantom
-- | Special pointer format to pass between memory spaces of processes.
newtype SharedPtr a = SharedPtr ( Ptr a )
  deriving (SharedPtr a -> SharedPtr a -> Bool
(SharedPtr a -> SharedPtr a -> Bool)
-> (SharedPtr a -> SharedPtr a -> Bool) -> Eq (SharedPtr a)
forall a. SharedPtr a -> SharedPtr a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SharedPtr a -> SharedPtr a -> Bool
$c/= :: forall a. SharedPtr a -> SharedPtr a -> Bool
== :: SharedPtr a -> SharedPtr a -> Bool
$c== :: forall a. SharedPtr a -> SharedPtr a -> Bool
Eq, Eq (SharedPtr a)
Eq (SharedPtr a)
-> (SharedPtr a -> SharedPtr a -> Ordering)
-> (SharedPtr a -> SharedPtr a -> Bool)
-> (SharedPtr a -> SharedPtr a -> Bool)
-> (SharedPtr a -> SharedPtr a -> Bool)
-> (SharedPtr a -> SharedPtr a -> Bool)
-> (SharedPtr a -> SharedPtr a -> SharedPtr a)
-> (SharedPtr a -> SharedPtr a -> SharedPtr a)
-> Ord (SharedPtr a)
SharedPtr a -> SharedPtr a -> Bool
SharedPtr a -> SharedPtr a -> Ordering
SharedPtr a -> SharedPtr a -> SharedPtr a
forall a. Eq (SharedPtr a)
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
forall a. SharedPtr a -> SharedPtr a -> Bool
forall a. SharedPtr a -> SharedPtr a -> Ordering
forall a. SharedPtr a -> SharedPtr a -> SharedPtr a
min :: SharedPtr a -> SharedPtr a -> SharedPtr a
$cmin :: forall a. SharedPtr a -> SharedPtr a -> SharedPtr a
max :: SharedPtr a -> SharedPtr a -> SharedPtr a
$cmax :: forall a. SharedPtr a -> SharedPtr a -> SharedPtr a
>= :: SharedPtr a -> SharedPtr a -> Bool
$c>= :: forall a. SharedPtr a -> SharedPtr a -> Bool
> :: SharedPtr a -> SharedPtr a -> Bool
$c> :: forall a. SharedPtr a -> SharedPtr a -> Bool
<= :: SharedPtr a -> SharedPtr a -> Bool
$c<= :: forall a. SharedPtr a -> SharedPtr a -> Bool
< :: SharedPtr a -> SharedPtr a -> Bool
$c< :: forall a. SharedPtr a -> SharedPtr a -> Bool
compare :: SharedPtr a -> SharedPtr a -> Ordering
$ccompare :: forall a. SharedPtr a -> SharedPtr a -> Ordering
$cp1Ord :: forall a. Eq (SharedPtr a)
Ord, Int -> SharedPtr a -> ShowS
[SharedPtr a] -> ShowS
SharedPtr a -> String
(Int -> SharedPtr a -> ShowS)
-> (SharedPtr a -> String)
-> ([SharedPtr a] -> ShowS)
-> Show (SharedPtr a)
forall a. Int -> SharedPtr a -> ShowS
forall a. [SharedPtr a] -> ShowS
forall a. SharedPtr a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SharedPtr a] -> ShowS
$cshowList :: forall a. [SharedPtr a] -> ShowS
show :: SharedPtr a -> String
$cshow :: forall a. SharedPtr a -> String
showsPrec :: Int -> SharedPtr a -> ShowS
$cshowsPrec :: forall a. Int -> SharedPtr a -> ShowS
Show, Typeable (SharedPtr a)
DataType
Constr
Typeable (SharedPtr a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SharedPtr a -> c (SharedPtr a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SharedPtr a))
-> (SharedPtr a -> Constr)
-> (SharedPtr a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SharedPtr a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SharedPtr a)))
-> ((forall b. Data b => b -> b) -> SharedPtr a -> SharedPtr a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r)
-> (forall u. (forall d. Data d => d -> u) -> SharedPtr a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SharedPtr a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a))
-> Data (SharedPtr a)
SharedPtr a -> DataType
SharedPtr a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (SharedPtr a))
(forall b. Data b => b -> b) -> SharedPtr a -> SharedPtr a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedPtr a -> c (SharedPtr a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SharedPtr a)
forall a. Data a => Typeable (SharedPtr a)
forall a. Data a => SharedPtr a -> DataType
forall a. Data a => SharedPtr a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> SharedPtr a -> SharedPtr a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SharedPtr a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> SharedPtr a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SharedPtr a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedPtr a -> c (SharedPtr a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SharedPtr a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SharedPtr a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SharedPtr a -> u
forall u. (forall d. Data d => d -> u) -> SharedPtr a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SharedPtr a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedPtr a -> c (SharedPtr a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SharedPtr a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SharedPtr a))
$cSharedPtr :: Constr
$tSharedPtr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
gmapMp :: (forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
gmapM :: (forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SharedPtr a -> m (SharedPtr a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> SharedPtr a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SharedPtr a -> u
gmapQ :: (forall d. Data d => d -> u) -> SharedPtr a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> SharedPtr a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SharedPtr a -> r
gmapT :: (forall b. Data b => b -> b) -> SharedPtr a -> SharedPtr a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> SharedPtr a -> SharedPtr a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SharedPtr a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SharedPtr a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (SharedPtr a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SharedPtr a))
dataTypeOf :: SharedPtr a -> DataType
$cdataTypeOf :: forall a. Data a => SharedPtr a -> DataType
toConstr :: SharedPtr a -> Constr
$ctoConstr :: forall a. Data a => SharedPtr a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SharedPtr a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SharedPtr a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedPtr a -> c (SharedPtr a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SharedPtr a -> c (SharedPtr a)
$cp1Data :: forall a. Data a => Typeable (SharedPtr a)
Data, (forall x. SharedPtr a -> Rep (SharedPtr a) x)
-> (forall x. Rep (SharedPtr a) x -> SharedPtr a)
-> Generic (SharedPtr a)
forall x. Rep (SharedPtr a) x -> SharedPtr a
forall x. SharedPtr a -> Rep (SharedPtr a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SharedPtr a) x -> SharedPtr a
forall a x. SharedPtr a -> Rep (SharedPtr a) x
$cto :: forall a x. Rep (SharedPtr a) x -> SharedPtr a
$cfrom :: forall a x. SharedPtr a -> Rep (SharedPtr a) x
Generic, Ptr b -> Int -> IO (SharedPtr a)
Ptr b -> Int -> SharedPtr a -> IO ()
Ptr (SharedPtr a) -> IO (SharedPtr a)
Ptr (SharedPtr a) -> Int -> IO (SharedPtr a)
Ptr (SharedPtr a) -> Int -> SharedPtr a -> IO ()
Ptr (SharedPtr a) -> SharedPtr a -> IO ()
SharedPtr a -> Int
(SharedPtr a -> Int)
-> (SharedPtr a -> Int)
-> (Ptr (SharedPtr a) -> Int -> IO (SharedPtr a))
-> (Ptr (SharedPtr a) -> Int -> SharedPtr a -> IO ())
-> (forall b. Ptr b -> Int -> IO (SharedPtr a))
-> (forall b. Ptr b -> Int -> SharedPtr a -> IO ())
-> (Ptr (SharedPtr a) -> IO (SharedPtr a))
-> (Ptr (SharedPtr a) -> SharedPtr a -> IO ())
-> Storable (SharedPtr a)
forall b. Ptr b -> Int -> IO (SharedPtr a)
forall b. Ptr b -> Int -> SharedPtr a -> IO ()
forall a. Ptr (SharedPtr a) -> IO (SharedPtr a)
forall a. Ptr (SharedPtr a) -> Int -> IO (SharedPtr a)
forall a. Ptr (SharedPtr a) -> Int -> SharedPtr a -> IO ()
forall a. Ptr (SharedPtr a) -> SharedPtr a -> IO ()
forall a. SharedPtr a -> Int
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 b. Ptr b -> Int -> IO (SharedPtr a)
forall a b. Ptr b -> Int -> SharedPtr a -> IO ()
poke :: Ptr (SharedPtr a) -> SharedPtr a -> IO ()
$cpoke :: forall a. Ptr (SharedPtr a) -> SharedPtr a -> IO ()
peek :: Ptr (SharedPtr a) -> IO (SharedPtr a)
$cpeek :: forall a. Ptr (SharedPtr a) -> IO (SharedPtr a)
pokeByteOff :: Ptr b -> Int -> SharedPtr a -> IO ()
$cpokeByteOff :: forall a b. Ptr b -> Int -> SharedPtr a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (SharedPtr a)
$cpeekByteOff :: forall a b. Ptr b -> Int -> IO (SharedPtr a)
pokeElemOff :: Ptr (SharedPtr a) -> Int -> SharedPtr a -> IO ()
$cpokeElemOff :: forall a. Ptr (SharedPtr a) -> Int -> SharedPtr a -> IO ()
peekElemOff :: Ptr (SharedPtr a) -> Int -> IO (SharedPtr a)
$cpeekElemOff :: forall a. Ptr (SharedPtr a) -> Int -> IO (SharedPtr a)
alignment :: SharedPtr a -> Int
$calignment :: forall a. SharedPtr a -> Int
sizeOf :: SharedPtr a -> Int
$csizeOf :: forall a. SharedPtr a -> Int
Storable)

-- | @C@ structure, should not be inspected from Haskell code
data AllocatorT
-- | Opaque pointer to the allocator type defined in @C@ code.
type Allocator = Ptr AllocatorT


foreign import ccall unsafe "&shared_createAllocator"
  p'shared_createAllocator
    :: FunPtr (IO Allocator)

foreign import ccall unsafe "&shared_lookupAllocator"
  p'shared_lookupAllocator
    :: FunPtr (CString -> IO Allocator)

foreign import ccall unsafe "&shared_destroyAllocator"
  p'shared_destroyAllocator
    :: FunPtr (Allocator -> IO ())

foreign import ccall unsafe "&shared_getStoreName"
  p'shared_getStoreName
    :: FunPtr (Allocator -> CString)

foreign import ccall unsafe "&shared_ptrToShPtr"
  p'shared_ptrToShPtr
    :: FunPtr (Allocator -> Ptr a -> SharedPtr a)

foreign import ccall unsafe "&shared_shPtrToPtr"
  p'shared_shPtrToPtr
    :: FunPtr (Allocator -> SharedPtr a -> Ptr a)

foreign import ccall unsafe "&shared_malloc"
  p'shared_malloc
    :: FunPtr (Allocator -> CSize -> IO (Ptr a))

foreign import ccall unsafe "&shared_realloc"
  p'shared_realloc
    :: FunPtr (Allocator -> Ptr a -> CSize -> IO (Ptr a))

foreign import ccall unsafe "&shared_free"
  p'shared_free
    :: FunPtr (Allocator -> Ptr a -> IO ())


foreign import ccall unsafe "shared_createAllocator"
  c'shared_createAllocator
    :: IO Allocator

foreign import ccall unsafe "shared_lookupAllocator"
  c'shared_lookupAllocator
    :: CString -> IO Allocator

foreign import ccall unsafe "shared_destroyAllocator"
  c'shared_destroyAllocator
    :: Allocator -> IO ()

foreign import ccall unsafe "shared_getStoreName"
  c'shared_getStoreName
    :: Allocator -> CString

foreign import ccall unsafe "shared_ptrToShPtr"
  c'shared_ptrToShPtr
    :: Allocator -> Ptr a -> SharedPtr a

foreign import ccall unsafe "shared_shPtrToPtr"
  c'shared_shPtrToPtr
    :: Allocator -> SharedPtr a -> Ptr a

foreign import ccall unsafe "shared_malloc"
  c'shared_malloc
    :: Allocator -> CSize -> IO (Ptr a)

foreign import ccall unsafe "shared_realloc"
  c'shared_realloc
    :: Allocator -> Ptr a -> CSize -> IO (Ptr a)

foreign import ccall unsafe "shared_free"
  c'shared_free
    :: Allocator -> Ptr a -> IO ()



foreign import ccall unsafe "&vk_shared_malloc"
  p'vk_shared_malloc
    :: FunPtr
        (Ptr Void -> CSize -> CSize -> allocScope -> IO (Ptr Void))

foreign import ccall unsafe "&vk_shared_realloc"
  p'vk_shared_realloc
    :: FunPtr
        (Ptr Void -> Ptr Void -> CSize -> CSize -> allocScope -> IO (Ptr Void))

foreign import ccall unsafe "&vk_shared_free"
  p'vk_shared_free
    :: FunPtr (Ptr Void -> Ptr Void -> IO ())