module NanoVG.Internal.FFIHelpers
  (withCString
  ,useAsCStringLen'
  ,useAsPtr
  ,zero
  ,null
  ,bitMask
  ) where

import           Data.Bits ((.|.))
import           Data.ByteString hiding (null)
import qualified Data.Set as S
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import           Foreign.C.String (CString)
import           Foreign.C.Types
import           Foreign.Ptr
import           Prelude hiding (null)

-- | Marshal a Haskell string into a NUL terminated C string using temporary storage.
withCString :: T.Text -> (CString -> IO b) -> IO b
withCString :: Text -> (CString -> IO b) -> IO b
withCString Text
t = ByteString -> (CString -> IO b) -> IO b
forall a. ByteString -> (CString -> IO a) -> IO a
useAsCString (Text -> ByteString
T.encodeUtf8 Text
t)

-- | Wrapper around 'useAsCStringLen' that uses 'CUChar's
useAsCStringLen' :: ByteString -> ((Ptr CUChar,CInt) -> IO a) -> IO a
useAsCStringLen' :: ByteString -> ((Ptr CUChar, CInt) -> IO a) -> IO a
useAsCStringLen' ByteString
bs (Ptr CUChar, CInt) -> IO a
f = ByteString -> (CStringLen -> IO a) -> IO a
forall a. ByteString -> (CStringLen -> IO a) -> IO a
useAsCStringLen ByteString
bs (\(CString
ptr,Int
len) -> (Ptr CUChar, CInt) -> IO a
f (CString -> Ptr CUChar
forall a b. Ptr a -> Ptr b
castPtr CString
ptr,Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len))

-- | Wrapper around 'useAsCStringLen'' that discards the length
useAsPtr :: ByteString -> (Ptr CUChar -> IO a) -> IO a
useAsPtr :: ByteString -> (Ptr CUChar -> IO a) -> IO a
useAsPtr ByteString
bs Ptr CUChar -> IO a
f = ByteString -> ((Ptr CUChar, CInt) -> IO a) -> IO a
forall a. ByteString -> ((Ptr CUChar, CInt) -> IO a) -> IO a
useAsCStringLen' ByteString
bs (Ptr CUChar -> IO a
f (Ptr CUChar -> IO a)
-> ((Ptr CUChar, CInt) -> Ptr CUChar) -> (Ptr CUChar, CInt) -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Ptr CUChar, CInt) -> Ptr CUChar
forall a b. (a, b) -> a
fst)

-- | Marshalling helper for a constant zero
zero :: Num a => (a -> b) -> b
zero :: (a -> b) -> b
zero a -> b
f = a -> b
f a
0

-- | Marshalling helper for a constant 'nullPtr'
null :: (Ptr a -> b) -> b
null :: (Ptr a -> b) -> b
null Ptr a -> b
f = Ptr a -> b
f Ptr a
forall a. Ptr a
nullPtr

-- | Combine the values in the set using a bitwise or
bitMask :: Enum a => S.Set a -> CInt
bitMask :: Set a -> CInt
bitMask = (CInt -> CInt -> CInt) -> CInt -> Set CInt -> CInt
forall a b. (a -> b -> b) -> b -> Set a -> b
S.fold CInt -> CInt -> CInt
forall a. Bits a => a -> a -> a
(.|.) CInt
0 (Set CInt -> CInt) -> (Set a -> Set CInt) -> Set a -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> CInt) -> Set a -> Set CInt
forall b a. Ord b => (a -> b) -> Set a -> Set b
S.map (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (a -> Int) -> a -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum)