-- GENERATED by C->Haskell Compiler, version 0.28.1 Switcheroo, 1 April 2016 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "src/Kafka/Internal/RdKafka.chs" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE EmptyDataDecls #-}

module Kafka.Internal.RdKafka where
import qualified Foreign.C.String as C2HSImp
import qualified Foreign.C.Types as C2HSImp
import qualified Foreign.ForeignPtr as C2HSImp
import qualified Foreign.Ptr as C2HSImp
import qualified Foreign.Storable as C2HSImp
import qualified System.IO.Unsafe as C2HSImp



--import Control.Applicative
import Control.Monad
import Data.Word
import Foreign
import Foreign.C.Error
import Foreign.C.String
import Foreign.C.Types
import Kafka.Internal.RdKafkaEnum
import System.IO
import System.Posix.IO
import System.Posix.Types



type CInt64T = (C2HSImp.CLLong)
{-# LINE 20 "src/Kafka/Internal/RdKafka.chs" #-}

type CInt32T = (C2HSImp.CInt)
{-# LINE 21 "src/Kafka/Internal/RdKafka.chs" #-}


type CFilePtr = C2HSImp.Ptr (CFile)
{-# LINE 23 "src/Kafka/Internal/RdKafka.chs" #-}

type CSizePtr = C2HSImp.Ptr (CSize)
{-# LINE 24 "src/Kafka/Internal/RdKafka.chs" #-}


type Word8Ptr = Ptr Word8
type CCharBufPointer  = Ptr CChar

type RdKafkaMsgFlag = Int
rdKafkaMsgFlagFree :: RdKafkaMsgFlag
rdKafkaMsgFlagFree = 0x1
rdKafkaMsgFlagCopy :: RdKafkaMsgFlag
rdKafkaMsgFlagCopy = 0x2

-- Number of bytes allocated for an error buffer
nErrorBytes ::  Int
nErrorBytes = 1024 * 8

-- Helper functions
rdKafkaVersion :: (Int)
rdKafkaVersion =
  C2HSImp.unsafePerformIO $
  rdKafkaVersion'_ >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 41 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaVersionStr :: (String)
rdKafkaVersionStr =
  C2HSImp.unsafePerformIO $
  rdKafkaVersionStr'_ >>= \res ->
  C2HSImp.peekCString res >>= \res' ->
  return (res')

{-# LINE 44 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaErr2str :: (RdKafkaRespErrT) -> (String)
rdKafkaErr2str a1 =
  C2HSImp.unsafePerformIO $
  let {a1' = enumToCInt a1} in 
  rdKafkaErr2str'_ a1' >>= \res ->
  C2HSImp.peekCString res >>= \res' ->
  return (res')

{-# LINE 47 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaErrno2err :: (Int) -> (RdKafkaRespErrT)
rdKafkaErrno2err a1 =
  C2HSImp.unsafePerformIO $
  let {a1' = fromIntegral a1} in 
  rdKafkaErrno2err'_ a1' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 50 "src/Kafka/Internal/RdKafka.chs" #-}



kafkaErrnoString :: IO (String)
kafkaErrnoString = do
    (Errno num) <- getErrno
    return $ rdKafkaErr2str $ rdKafkaErrno2err (fromIntegral num)

-- Kafka Pointer Types
data RdKafkaConfT
type RdKafkaConfTPtr = C2HSImp.ForeignPtr (RdKafkaConfT)
{-# LINE 60 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaTopicConfT
type RdKafkaTopicConfTPtr = C2HSImp.ForeignPtr (RdKafkaTopicConfT)
{-# LINE 63 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaT
type RdKafkaTPtr = C2HSImp.ForeignPtr (RdKafkaT)
{-# LINE 66 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaTopicPartitionT = RdKafkaTopicPartitionT
    { topic'RdKafkaTopicPartitionT :: CString
    , partition'RdKafkaTopicPartitionT :: Int
    , offset'RdKafkaTopicPartitionT :: Int64
    , metadata'RdKafkaTopicPartitionT :: Word8Ptr
    , metadataSize'RdKafkaTopicPartitionT :: Int
    , opaque'RdKafkaTopicPartitionT :: Word8Ptr
    , err'RdKafkaTopicPartitionT :: RdKafkaRespErrT
    } deriving (Show, Eq)

instance Storable RdKafkaTopicPartitionT where
    alignment _ = 8
{-# LINE 79 "src/Kafka/Internal/RdKafka.chs" #-}

    sizeOf _ = 64
{-# LINE 80 "src/Kafka/Internal/RdKafka.chs" #-}

    peek p = RdKafkaTopicPartitionT
        <$> liftM id           ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO C2HSImp.CInt}) p)
        <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 16 :: IO C2HSImp.CLLong}) p)
        <*> liftM castPtr      ((\ptr -> do {C2HSImp.peekByteOff ptr 24 :: IO (C2HSImp.Ptr ())}) p)
        <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 32 :: IO C2HSImp.CULong}) p)
        <*> liftM castPtr      ((\ptr -> do {C2HSImp.peekByteOff ptr 40 :: IO (C2HSImp.Ptr ())}) p)
        <*> liftM cIntToEnum   ((\ptr -> do {C2HSImp.peekByteOff ptr 48 :: IO C2HSImp.CInt}) p)
    poke p x = do
        (\ptr val -> do {C2HSImp.pokeByteOff ptr 0 (val :: (C2HSImp.Ptr C2HSImp.CChar))})         p (id           $ topic'RdKafkaTopicPartitionT x)
        (\ptr val -> do {C2HSImp.pokeByteOff ptr 8 (val :: C2HSImp.CInt)})     p (fromIntegral $ partition'RdKafkaTopicPartitionT x)
        (\ptr val -> do {C2HSImp.pokeByteOff ptr 16 (val :: C2HSImp.CLLong)})        p (fromIntegral $ offset'RdKafkaTopicPartitionT x)
        (\ptr val -> do {C2HSImp.pokeByteOff ptr 24 (val :: (C2HSImp.Ptr ()))})      p (castPtr      $ metadata'RdKafkaTopicPartitionT x)
        (\ptr val -> do {C2HSImp.pokeByteOff ptr 32 (val :: C2HSImp.CULong)}) p (fromIntegral $ metadataSize'RdKafkaTopicPartitionT x)
        (\ptr val -> do {C2HSImp.pokeByteOff ptr 40 (val :: (C2HSImp.Ptr ()))})        p (castPtr      $ opaque'RdKafkaTopicPartitionT x)
        (\ptr val -> do {C2HSImp.pokeByteOff ptr 48 (val :: C2HSImp.CInt)})           p (enumToCInt   $ err'RdKafkaTopicPartitionT x)

type RdKafkaTopicPartitionTPtr = C2HSImp.ForeignPtr (RdKafkaTopicPartitionT)
{-# LINE 98 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaTopicPartitionListT = RdKafkaTopicPartitionListT
    { cnt'RdKafkaTopicPartitionListT   :: Int
    , size'RdKafkaTopicPartitionListT  :: Int
    , elems'RdKafkaTopicPartitionListT :: Ptr RdKafkaTopicPartitionT
    } deriving (Show, Eq)

type RdKafkaTopicPartitionListTPtr = C2HSImp.ForeignPtr (RdKafkaTopicPartitionListT)
{-# LINE 106 "src/Kafka/Internal/RdKafka.chs" #-}


instance Storable RdKafkaTopicPartitionListT where
  alignment _ = 8
{-# LINE 109 "src/Kafka/Internal/RdKafka.chs" #-}

  sizeOf _    = 16
{-# LINE 110 "src/Kafka/Internal/RdKafka.chs" #-}

  peek p = RdKafkaTopicPartitionListT
    <$> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO C2HSImp.CInt}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 4 :: IO C2HSImp.CInt}) p)
    <*> liftM castPtr      ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO (C2HSImp.Ptr (RdKafkaTopicPartitionT))}) p)
  poke p x = do
    (\ptr val -> do {C2HSImp.pokeByteOff ptr 0 (val :: C2HSImp.CInt)})   p (fromIntegral $ cnt'RdKafkaTopicPartitionListT x)
    (\ptr val -> do {C2HSImp.pokeByteOff ptr 4 (val :: C2HSImp.CInt)})  p (fromIntegral $ size'RdKafkaTopicPartitionListT x)
    (\ptr val -> do {C2HSImp.pokeByteOff ptr 8 (val :: (C2HSImp.Ptr (RdKafkaTopicPartitionT)))}) p (castPtr      $ elems'RdKafkaTopicPartitionListT x)

data RdKafkaTopicT
type RdKafkaTopicTPtr = C2HSImp.ForeignPtr (RdKafkaTopicT)
{-# LINE 121 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaMessageT = RdKafkaMessageT
    { err'RdKafkaMessageT :: RdKafkaRespErrT
    , topic'RdKafkaMessageT :: Ptr RdKafkaTopicT
    , partition'RdKafkaMessageT :: Int
    , len'RdKafkaMessageT :: Int
    , keyLen'RdKafkaMessageT :: Int
    , offset'RdKafkaMessageT :: Int64
    , payload'RdKafkaMessageT :: Word8Ptr
    , key'RdKafkaMessageT :: Word8Ptr
    }
    deriving (Show, Eq)

instance Storable RdKafkaMessageT where
    alignment _ = 8
{-# LINE 136 "src/Kafka/Internal/RdKafka.chs" #-}

    sizeOf _ = 72
{-# LINE 137 "src/Kafka/Internal/RdKafka.chs" #-}

    peek p = RdKafkaMessageT
        <$> liftM cIntToEnum    ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO C2HSImp.CInt}) p)
        <*> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO (C2HSImp.Ptr (RdKafkaTopicT))}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 16 :: IO C2HSImp.CInt}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 32 :: IO C2HSImp.CULong}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 48 :: IO C2HSImp.CULong}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 56 :: IO C2HSImp.CLLong}) p)
        <*> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 24 :: IO (C2HSImp.Ptr ())}) p)
        <*> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 40 :: IO (C2HSImp.Ptr ())}) p)
    poke p x = do
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 0 (val :: C2HSImp.CInt)})        p (enumToCInt   $ err'RdKafkaMessageT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 8 (val :: (C2HSImp.Ptr (RdKafkaTopicT)))})        p (castPtr      $ topic'RdKafkaMessageT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 16 (val :: C2HSImp.CInt)})  p (fromIntegral $ partition'RdKafkaMessageT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 32 (val :: C2HSImp.CULong)})        p (fromIntegral $ len'RdKafkaMessageT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 48 (val :: C2HSImp.CULong)})    p (fromIntegral $ keyLen'RdKafkaMessageT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 56 (val :: C2HSImp.CLLong)})     p (fromIntegral $ offset'RdKafkaMessageT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 24 (val :: (C2HSImp.Ptr ()))})    p (castPtr      $ payload'RdKafkaMessageT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 40 (val :: (C2HSImp.Ptr ()))})        p (castPtr      $ key'RdKafkaMessageT x)

type RdKafkaMessageTPtr = C2HSImp.ForeignPtr (RdKafkaMessageT)
{-# LINE 157 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaMetadataBrokerT = RdKafkaMetadataBrokerT
  { id'RdKafkaMetadataBrokerT  :: Int
  , host'RdKafkaMetadataBrokerT :: CString
  , port'RdKafkaMetadataBrokerT :: Int
  } deriving (Show, Eq)

type RdKafkaMetadataBrokerTPtr = C2HSImp.Ptr (RdKafkaMetadataBrokerT)
{-# LINE 165 "src/Kafka/Internal/RdKafka.chs" #-}



instance Storable RdKafkaMetadataBrokerT where
  alignment _ = 8
{-# LINE 169 "src/Kafka/Internal/RdKafka.chs" #-}

  sizeOf _ = 24
{-# LINE 170 "src/Kafka/Internal/RdKafka.chs" #-}

  peek p = RdKafkaMetadataBrokerT
    <$> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO C2HSImp.CInt}) p)
    <*> liftM id ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 16 :: IO C2HSImp.CInt}) p)
  poke = undefined

data RdKafkaMetadataPartitionT = RdKafkaMetadataPartitionT
  { id'RdKafkaMetadataPartitionT :: Int
  , err'RdKafkaMetadataPartitionT :: RdKafkaRespErrT
  , leader'RdKafkaMetadataPartitionT :: Int
  , replicaCnt'RdKafkaMetadataPartitionT :: Int
  , replicas'RdKafkaMetadataPartitionT :: Ptr CInt32T
  , isrCnt'RdKafkaMetadataPartitionT :: Int
  , isrs'RdKafkaMetadataPartitionT :: Ptr CInt32T
  } deriving (Show, Eq)

instance Storable RdKafkaMetadataPartitionT where
  alignment _ = 8
{-# LINE 188 "src/Kafka/Internal/RdKafka.chs" #-}

  sizeOf _ = 40
{-# LINE 189 "src/Kafka/Internal/RdKafka.chs" #-}

  peek p = RdKafkaMetadataPartitionT
    <$> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO C2HSImp.CInt}) p)
    <*> liftM cIntToEnum ((\ptr -> do {C2HSImp.peekByteOff ptr 4 :: IO C2HSImp.CInt}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO C2HSImp.CInt}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 12 :: IO C2HSImp.CInt}) p)
    <*> liftM castPtr ((\ptr -> do {C2HSImp.peekByteOff ptr 16 :: IO (C2HSImp.Ptr C2HSImp.CInt)}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 24 :: IO C2HSImp.CInt}) p)
    <*> liftM castPtr ((\ptr -> do {C2HSImp.peekByteOff ptr 32 :: IO (C2HSImp.Ptr C2HSImp.CInt)}) p)

  poke = undefined

type RdKafkaMetadataPartitionTPtr = C2HSImp.Ptr (RdKafkaMetadataPartitionT)
{-# LINE 201 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaMetadataTopicT = RdKafkaMetadataTopicT
  { topic'RdKafkaMetadataTopicT :: CString
  , partitionCnt'RdKafkaMetadataTopicT :: Int
  , partitions'RdKafkaMetadataTopicT :: Ptr RdKafkaMetadataPartitionT
  , err'RdKafkaMetadataTopicT :: RdKafkaRespErrT
  } deriving (Show, Eq)

instance Storable RdKafkaMetadataTopicT where
  alignment _ = 8
{-# LINE 211 "src/Kafka/Internal/RdKafka.chs" #-}

  sizeOf _ = 32
{-# LINE 212 "src/Kafka/Internal/RdKafka.chs" #-}

  peek p = RdKafkaMetadataTopicT
    <$> liftM id ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO C2HSImp.CInt}) p)
    <*> liftM castPtr ((\ptr -> do {C2HSImp.peekByteOff ptr 16 :: IO (C2HSImp.Ptr ())}) p)
    <*> liftM cIntToEnum ((\ptr -> do {C2HSImp.peekByteOff ptr 24 :: IO C2HSImp.CInt}) p)
  poke _ _ = undefined

type RdKafkaMetadataTopicTPtr = C2HSImp.Ptr (RdKafkaMetadataTopicT)
{-# LINE 220 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaMetadataT = RdKafkaMetadataT
  { brokerCnt'RdKafkaMetadataT :: Int
  , brokers'RdKafkaMetadataT :: RdKafkaMetadataBrokerTPtr
  , topicCnt'RdKafkaMetadataT :: Int
  , topics'RdKafkaMetadataT :: RdKafkaMetadataTopicTPtr
  , origBrokerId'RdKafkaMetadataT :: CInt32T
  } deriving (Show, Eq)

instance Storable RdKafkaMetadataT where
  alignment _ = 8
{-# LINE 231 "src/Kafka/Internal/RdKafka.chs" #-}

  sizeOf _ = 48
{-# LINE 232 "src/Kafka/Internal/RdKafka.chs" #-}

  peek p = RdKafkaMetadataT
    <$> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO C2HSImp.CInt}) p)
    <*> liftM castPtr ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO (C2HSImp.Ptr ())}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 16 :: IO C2HSImp.CInt}) p)
    <*> liftM castPtr ((\ptr -> do {C2HSImp.peekByteOff ptr 24 :: IO (C2HSImp.Ptr ())}) p)
    <*> liftM fromIntegral ((\ptr -> do {C2HSImp.peekByteOff ptr 32 :: IO C2HSImp.CInt}) p)
  poke _ _ = undefined

type RdKafkaMetadataTPtr = C2HSImp.ForeignPtr (RdKafkaMetadataT)
{-# LINE 241 "src/Kafka/Internal/RdKafka.chs" #-}


-------------------------------------------------------------------------------------------------
---- Partitions
rdKafkaTopicPartitionListNew :: (Int) -> IO ((RdKafkaTopicPartitionListTPtr))
rdKafkaTopicPartitionListNew a1 =
  let {a1' = fromIntegral a1} in 
  rdKafkaTopicPartitionListNew'_ a1' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 246 "src/Kafka/Internal/RdKafka.chs" #-}


foreign import ccall unsafe "rdkafka.h &rd_kafka_topic_partition_list_destroy"
    rdKafkaTopicPartitionListDestroy :: FunPtr (Ptr RdKafkaTopicPartitionListT -> IO ())

newRdKafkaTopicPartitionListT :: Int -> IO RdKafkaTopicPartitionListTPtr
newRdKafkaTopicPartitionListT size = do
    ret <- rdKafkaTopicPartitionListNew size
    addForeignPtrFinalizer rdKafkaTopicPartitionListDestroy ret
    return ret

rdKafkaTopicPartitionListAdd :: (RdKafkaTopicPartitionListTPtr) -> (String) -> (Int) -> IO ((RdKafkaTopicPartitionTPtr))
rdKafkaTopicPartitionListAdd a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  let {a3' = fromIntegral a3} in 
  rdKafkaTopicPartitionListAdd'_ a1' a2' a3' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 258 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaTopicPartitionListAddRange :: (RdKafkaTopicPartitionListTPtr) -> (String) -> (Int) -> (Int) -> IO ()
rdKafkaTopicPartitionListAddRange a1 a2 a3 a4 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  let {a3' = fromIntegral a3} in 
  let {a4' = fromIntegral a4} in 
  rdKafkaTopicPartitionListAddRange'_ a1' a2' a3' a4' >>
  return ()

{-# LINE 261 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaTopicPartitionListCopy :: (RdKafkaTopicPartitionListTPtr) -> IO ((RdKafkaTopicPartitionListTPtr))
rdKafkaTopicPartitionListCopy a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaTopicPartitionListCopy'_ a1' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 264 "src/Kafka/Internal/RdKafka.chs" #-}


copyRdKafkaTopicPartitionList :: RdKafkaTopicPartitionListTPtr -> IO RdKafkaTopicPartitionListTPtr
copyRdKafkaTopicPartitionList pl = do
    cp <- rdKafkaTopicPartitionListCopy pl
    addForeignPtrFinalizer rdKafkaTopicPartitionListDestroy cp
    return cp

rdKafkaTopicPartitionListSetOffset :: (RdKafkaTopicPartitionListTPtr) -> (String) -> (Int) -> (Int64) -> IO ((RdKafkaRespErrT))
rdKafkaTopicPartitionListSetOffset a1 a2 a3 a4 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  let {a3' = fromIntegral a3} in 
  let {a4' = fromIntegral a4} in 
  rdKafkaTopicPartitionListSetOffset'_ a1' a2' a3' a4' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 274 "src/Kafka/Internal/RdKafka.chs" #-}


---- Rebalance Callback
type RdRebalanceCallback' = Ptr RdKafkaT -> CInt -> Ptr RdKafkaTopicPartitionListT -> Ptr Word8 -> IO ()
type RdRebalanceCallback = Ptr RdKafkaT -> RdKafkaRespErrT -> Ptr RdKafkaTopicPartitionListT -> Ptr Word8 -> IO ()

foreign import ccall safe "wrapper"
    mkRebalanceCallback :: RdRebalanceCallback' -> IO (FunPtr RdRebalanceCallback')

foreign import ccall safe "rd_kafka.h rd_kafka_conf_set_rebalance_cb"
     rdKafkaConfSetRebalanceCb' ::
       Ptr RdKafkaConfT
       -> FunPtr RdRebalanceCallback'
       -> IO ()

rdKafkaConfSetRebalanceCb :: RdKafkaConfTPtr -> RdRebalanceCallback -> IO ()
rdKafkaConfSetRebalanceCb conf cb = do
    cb' <- mkRebalanceCallback (\k e p o -> cb k (cIntToEnum e) p o)
    withForeignPtr conf $ \c -> rdKafkaConfSetRebalanceCb' c cb'
    return ()

---- Delivery Callback
type DeliveryCallback = Ptr RdKafkaT -> Ptr RdKafkaMessageT -> Word8Ptr -> IO ()

foreign import ccall safe "wrapper"
    mkDeliveryCallback :: DeliveryCallback -> IO (FunPtr DeliveryCallback)

foreign import ccall safe "rd_kafka.h rd_kafka_conf_set_dr_msg_cb"
    rdKafkaConfSetDrMsgCb' :: Ptr RdKafkaConfT -> FunPtr DeliveryCallback -> IO ()

rdKafkaConfSetDrMsgCb :: RdKafkaConfTPtr -> DeliveryCallback -> IO ()
rdKafkaConfSetDrMsgCb conf cb = do
    cb' <- mkDeliveryCallback cb
    withForeignPtr conf $ \c -> rdKafkaConfSetDrMsgCb' c cb'
    return ()

---- Consume Callback
type ConsumeCallback = Ptr RdKafkaMessageT -> Word8Ptr -> IO ()

foreign import ccall safe "wrapper"
    mkConsumeCallback :: ConsumeCallback -> IO (FunPtr ConsumeCallback)

foreign import ccall safe "rd_kafka.h rd_kafka_conf_set_consume_cb"
    rdKafkaConfSetConsumeCb' :: Ptr RdKafkaConfT -> FunPtr ConsumeCallback -> IO ()

rdKafkaConfSetConsumeCb :: RdKafkaConfTPtr -> ConsumeCallback -> IO ()
rdKafkaConfSetConsumeCb conf cb = do
    cb' <- mkConsumeCallback cb
    withForeignPtr conf $ \c -> rdKafkaConfSetConsumeCb' c cb'
    return ()

---- Offset Commit Callback
type OffsetCommitCallback' = Ptr RdKafkaT -> CInt -> Ptr RdKafkaTopicPartitionListT -> Word8Ptr -> IO ()
type OffsetCommitCallback  = Ptr RdKafkaT -> RdKafkaRespErrT -> Ptr RdKafkaTopicPartitionListT -> Word8Ptr -> IO ()

foreign import ccall safe "wrapper"
    mkOffsetCommitCallback :: OffsetCommitCallback' -> IO (FunPtr OffsetCommitCallback')

foreign import ccall safe "rd_kafka.h rd_kafka_conf_set_offset_commit_cb"
    rdKafkaConfSetOffsetCommitCb' :: Ptr RdKafkaConfT -> FunPtr OffsetCommitCallback' -> IO ()

rdKafkaConfSetOffsetCommitCb :: RdKafkaConfTPtr -> OffsetCommitCallback -> IO ()
rdKafkaConfSetOffsetCommitCb conf cb = do
    cb' <- mkOffsetCommitCallback (\k e p o -> cb k (cIntToEnum e) p o)
    withForeignPtr conf $ \c -> rdKafkaConfSetOffsetCommitCb' c cb'
    return ()

---- Throttle Callback
type ThrottleCallback = Ptr RdKafkaT -> CString -> Int -> Int -> Word8Ptr -> IO ()

foreign import ccall safe "wrapper"
    mkThrottleCallback :: ThrottleCallback -> IO (FunPtr ThrottleCallback)

foreign import ccall safe "rd_kafka.h rd_kafka_conf_set_throttle_cb"
    rdKafkaConfSetThrottleCb' :: Ptr RdKafkaConfT -> FunPtr ThrottleCallback -> IO ()

rdKafkaConfSetThrottleCb :: RdKafkaConfTPtr -> ThrottleCallback -> IO ()
rdKafkaConfSetThrottleCb conf cb = do
    cb' <- mkThrottleCallback cb
    withForeignPtr conf $ \c -> rdKafkaConfSetThrottleCb' c cb'
    return ()

---- Stats Callback
type StatsCallback = Ptr RdKafkaT -> CString -> CSize -> Word8Ptr -> IO ()

foreign import ccall safe "wrapper"
    mkStatsCallback :: StatsCallback -> IO (FunPtr StatsCallback)

foreign import ccall safe "rd_kafka.h rd_kafka_conf_set_stats_cb"
    rdKafkaConfSetStatsCb' :: Ptr RdKafkaConfT -> FunPtr StatsCallback -> IO ()

rdKafkaConfSetStatsCb :: RdKafkaConfTPtr -> StatsCallback -> IO ()
rdKafkaConfSetStatsCb conf cb = do
    cb' <- mkStatsCallback cb
    withForeignPtr conf $ \c -> rdKafkaConfSetStatsCb' c cb'
    return ()

---- Socket Callback
type SocketCallback = Int -> Int -> Int -> Word8Ptr -> IO ()

foreign import ccall safe "wrapper"
    mkSocketCallback :: SocketCallback -> IO (FunPtr SocketCallback)

foreign import ccall safe "rd_kafka.h rd_kafka_conf_set_socket_cb"
    rdKafkaConfSetSocketCb' :: Ptr RdKafkaConfT -> FunPtr SocketCallback -> IO ()

rdKafkaConfSetSocketCb :: RdKafkaConfTPtr -> SocketCallback -> IO ()
rdKafkaConfSetSocketCb conf cb = do
    cb' <- mkSocketCallback cb
    withForeignPtr conf $ \c -> rdKafkaConfSetSocketCb' c cb'
    return ()

rdKafkaConfSetOpaque :: (RdKafkaConfTPtr) -> (Word8Ptr) -> IO ()
rdKafkaConfSetOpaque a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  rdKafkaConfSetOpaque'_ a1' a2' >>
  return ()

{-# LINE 387 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaOpaque :: (RdKafkaTPtr) -> IO ((Word8Ptr))
rdKafkaOpaque a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaOpaque'_ a1' >>= \res ->
  let {res' = castPtr res} in
  return (res')

{-# LINE 390 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConfSetDefaultTopicConf :: (RdKafkaConfTPtr) -> (RdKafkaTopicConfTPtr) -> IO ()
rdKafkaConfSetDefaultTopicConf a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  rdKafkaConfSetDefaultTopicConf'_ a1' a2' >>
  return ()

{-# LINE 393 "src/Kafka/Internal/RdKafka.chs" #-}


---- Partitioner Callback
type PartitionerCallback =
    Ptr RdKafkaTopicTPtr
    -> Word8Ptr    -- keydata
    -> Int         -- keylen
    -> Int         -- partition_cnt
    -> Word8Ptr    -- topic_opaque
    -> Word8Ptr    -- msg_opaque
    -> IO Int

foreign import ccall safe "wrapper"
    mkPartitionerCallback :: PartitionerCallback -> IO (FunPtr PartitionerCallback)

foreign import ccall safe "rd_kafka.h rd_kafka_topic_conf_set_partitioner_cb"
    rdKafkaTopicConfSetPartitionerCb' :: Ptr RdKafkaTopicConfT -> FunPtr PartitionerCallback -> IO ()

rdKafkaTopicConfSetPartitionerCb :: RdKafkaTopicConfTPtr -> PartitionerCallback -> IO ()
rdKafkaTopicConfSetPartitionerCb conf cb = do
    cb' <- mkPartitionerCallback cb
    withForeignPtr conf $ \c -> rdKafkaTopicConfSetPartitionerCb' c cb'
    return ()

---- Partition

rdKafkaTopicPartitionAvailable :: (RdKafkaTopicTPtr) -> (CInt32T) -> IO ((Int))
rdKafkaTopicPartitionAvailable a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  rdKafkaTopicPartitionAvailable'_ a1' a2' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 420 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaMsgPartitionerRandom :: (RdKafkaTopicTPtr) -> (Word8Ptr) -> (CSize) -> (CInt32T) -> (Word8Ptr) -> (Word8Ptr) -> IO ((CInt32T))
rdKafkaMsgPartitionerRandom a1 a2 a3 a4 a5 a6 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  let {a3' = cIntConv a3} in 
  let {a4' = cIntConv a4} in 
  let {a5' = castPtr a5} in 
  let {a6' = castPtr a6} in 
  rdKafkaMsgPartitionerRandom'_ a1' a2' a3' a4' a5' a6' >>= \res ->
  let {res' = cIntConv res} in
  return (res')

{-# LINE 429 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaMsgPartitionerConsistent :: (RdKafkaTopicTPtr) -> (Word8Ptr) -> (CSize) -> (CInt32T) -> (Word8Ptr) -> (Word8Ptr) -> IO ((CInt32T))
rdKafkaMsgPartitionerConsistent a1 a2 a3 a4 a5 a6 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  let {a3' = cIntConv a3} in 
  let {a4' = cIntConv a4} in 
  let {a5' = castPtr a5} in 
  let {a6' = castPtr a6} in 
  rdKafkaMsgPartitionerConsistent'_ a1' a2' a3' a4' a5' a6' >>= \res ->
  let {res' = cIntConv res} in
  return (res')

{-# LINE 438 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaMsgPartitionerConsistentRandom :: (RdKafkaTopicTPtr) -> (Word8Ptr) -> (CSize) -> (CInt32T) -> (Word8Ptr) -> (Word8Ptr) -> IO ((CInt32T))
rdKafkaMsgPartitionerConsistentRandom a1 a2 a3 a4 a5 a6 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  let {a3' = cIntConv a3} in 
  let {a4' = cIntConv a4} in 
  let {a5' = castPtr a5} in 
  let {a6' = castPtr a6} in 
  rdKafkaMsgPartitionerConsistentRandom'_ a1' a2' a3' a4' a5' a6' >>= \res ->
  let {res' = cIntConv res} in
  return (res')

{-# LINE 447 "src/Kafka/Internal/RdKafka.chs" #-}


---- Poll / Yield

rdKafkaYield :: (RdKafkaTPtr) -> IO ()
rdKafkaYield a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaYield'_ a1' >>
  return ()

{-# LINE 452 "src/Kafka/Internal/RdKafka.chs" #-}


---- Pause / Resume
rdKafkaPausePartitions :: (RdKafkaTPtr) -> (RdKafkaTopicPartitionListTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaPausePartitions a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  rdKafkaPausePartitions'_ a1' a2' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 456 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaResumePartitions :: (RdKafkaTPtr) -> (RdKafkaTopicPartitionListTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaResumePartitions a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  rdKafkaResumePartitions'_ a1' a2' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 459 "src/Kafka/Internal/RdKafka.chs" #-}


---- QUEUE
data RdKafkaQueueT
type RdKafkaQueueTPtr = C2HSImp.ForeignPtr (RdKafkaQueueT)
{-# LINE 463 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaQueueNew :: (RdKafkaTPtr) -> IO ((RdKafkaQueueTPtr))
rdKafkaQueueNew a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaQueueNew'_ a1' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 466 "src/Kafka/Internal/RdKafka.chs" #-}


foreign import ccall unsafe "rdkafka.h &rd_kafka_queue_destroy"
    rdKafkaQueueDestroy :: FunPtr (Ptr RdKafkaQueueT -> IO ())

newRdKafkaQueue :: RdKafkaTPtr -> IO RdKafkaQueueTPtr
newRdKafkaQueue k = do
    q <- rdKafkaQueueNew k
    addForeignPtrFinalizer rdKafkaQueueDestroy q
    return q
-------------------------------------------------------------------------------------------------
---- High-level KafkaConsumer

rdKafkaSubscribe :: (RdKafkaTPtr) -> (RdKafkaTopicPartitionListTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaSubscribe a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  rdKafkaSubscribe'_ a1' a2' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 481 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaUnsubscribe :: (RdKafkaTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaUnsubscribe a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaUnsubscribe'_ a1' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 485 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaSubscription :: (RdKafkaTPtr) -> (Ptr (Ptr RdKafkaTopicPartitionListT)) -> IO ((RdKafkaRespErrT))
rdKafkaSubscription a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  rdKafkaSubscription'_ a1' a2' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 489 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConsumerPoll :: (RdKafkaTPtr) -> (Int) -> IO ((RdKafkaMessageTPtr))
rdKafkaConsumerPoll a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  rdKafkaConsumerPoll'_ a1' a2' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 492 "src/Kafka/Internal/RdKafka.chs" #-}


pollRdKafkaConsumer :: RdKafkaTPtr -> Int -> IO RdKafkaMessageTPtr
pollRdKafkaConsumer k t = do
    m <- rdKafkaConsumerPoll k t
    addForeignPtrFinalizer rdKafkaMessageDestroyF m
    return m

rdKafkaConsumerClose :: (RdKafkaTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaConsumerClose a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaConsumerClose'_ a1' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 501 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaPollSetConsumer :: (RdKafkaTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaPollSetConsumer a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaPollSetConsumer'_ a1' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 504 "src/Kafka/Internal/RdKafka.chs" #-}


-- rd_kafka_assign
rdKafkaAssign :: (RdKafkaTPtr) -> (RdKafkaTopicPartitionListTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaAssign a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  rdKafkaAssign'_ a1' a2' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 509 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaAssignment :: (RdKafkaTPtr) -> (Ptr (Ptr RdKafkaTopicPartitionListT)) -> IO ((RdKafkaRespErrT))
rdKafkaAssignment a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  rdKafkaAssignment'_ a1' a2' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 513 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaCommit :: (RdKafkaTPtr) -> (RdKafkaTopicPartitionListTPtr) -> (Bool) -> IO ((RdKafkaRespErrT))
rdKafkaCommit a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  let {a3' = boolToCInt a3} in 
  rdKafkaCommit'_ a1' a2' a3' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 517 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaCommitMessage :: (RdKafkaTPtr) -> (RdKafkaMessageTPtr) -> (Bool) -> IO ((RdKafkaRespErrT))
rdKafkaCommitMessage a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  let {a3' = boolToCInt a3} in 
  rdKafkaCommitMessage'_ a1' a2' a3' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 521 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaCommitted :: (RdKafkaTPtr) -> (RdKafkaTopicPartitionListTPtr) -> (Int) -> IO ((RdKafkaRespErrT))
rdKafkaCommitted a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  let {a3' = fromIntegral a3} in 
  rdKafkaCommitted'_ a1' a2' a3' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 525 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaPosition :: (RdKafkaTPtr) -> (RdKafkaTopicPartitionListTPtr) -> IO ((RdKafkaRespErrT))
rdKafkaPosition a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  rdKafkaPosition'_ a1' a2' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 529 "src/Kafka/Internal/RdKafka.chs" #-}


-------------------------------------------------------------------------------------------------
---- Groups
data RdKafkaGroupMemberInfoT = RdKafkaGroupMemberInfoT
    { memberId'RdKafkaGroupMemberInfoT              :: CString
    , clientId'RdKafkaGroupMemberInfoT              :: CString
    , clientHost'RdKafkaGroupMemberInfoT            :: CString
    , memberMetadata'RdKafkaGroupMemberInfoT        :: Word8Ptr
    , memberMetadataSize'RdKafkaGroupMemberInfoT    :: Int
    , memberAssignment'RdKafkaGroupMemberInfoT      :: Word8Ptr
    , memberAssignmentSize'RdKafkaGroupMemberInfoT  :: Int }

instance Storable RdKafkaGroupMemberInfoT where
    alignment _ = 8
{-# LINE 543 "src/Kafka/Internal/RdKafka.chs" #-}

    sizeOf _ = 56
{-# LINE 544 "src/Kafka/Internal/RdKafka.chs" #-}

    peek p = RdKafkaGroupMemberInfoT
        <$> liftM id            ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM id            ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM id            ((\ptr -> do {C2HSImp.peekByteOff ptr 16 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 24 :: IO (C2HSImp.Ptr ())}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 32 :: IO C2HSImp.CInt}) p)
        <*> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 40 :: IO (C2HSImp.Ptr ())}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 48 :: IO C2HSImp.CInt}) p)
    poke p x = do
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 0 (val :: (C2HSImp.Ptr C2HSImp.CChar))})              p (id           $ memberId'RdKafkaGroupMemberInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 8 (val :: (C2HSImp.Ptr C2HSImp.CChar))})              p (id           $ clientId'RdKafkaGroupMemberInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 16 (val :: (C2HSImp.Ptr C2HSImp.CChar))})            p (id           $ clientHost'RdKafkaGroupMemberInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 24 (val :: (C2HSImp.Ptr ()))})        p (castPtr      $ memberMetadata'RdKafkaGroupMemberInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 32 (val :: C2HSImp.CInt)})   p (fromIntegral $ memberMetadataSize'RdKafkaGroupMemberInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 40 (val :: (C2HSImp.Ptr ()))})      p (castPtr      $ memberAssignment'RdKafkaGroupMemberInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 48 (val :: C2HSImp.CInt)}) p (fromIntegral $ memberAssignmentSize'RdKafkaGroupMemberInfoT x)

type RdKafkaGroupMemberInfoTPtr = C2HSImp.ForeignPtr (RdKafkaGroupMemberInfoT)
{-# LINE 562 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaGroupInfoT = RdKafkaGroupInfoT
    { broker'RdKafkaGroupInfoT       :: Ptr RdKafkaMetadataBrokerT
    , group'RdKafkaGroupInfoT        :: CString
    , err'RdKafkaGroupInfoT          :: RdKafkaRespErrT
    , state'RdKafkaGroupInfoT        :: CString
    , protocolType'RdKafkaGroupInfoT :: CString
    , protocol'RdKafkaGroupInfoT     :: CString
    , members'RdKafkaGroupInfoT      :: Ptr RdKafkaGroupMemberInfoT
    , memberCnt'RdKafkaGroupInfoT    :: Int }

instance Storable RdKafkaGroupInfoT where
    alignment _ = 8
{-# LINE 575 "src/Kafka/Internal/RdKafka.chs" #-}

    sizeOf _ = 80
{-# LINE 576 "src/Kafka/Internal/RdKafka.chs" #-}

    peek p = RdKafkaGroupInfoT
        <$> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO (C2HSImp.Ptr ())}) p)
        <*> liftM id            ((\ptr -> do {C2HSImp.peekByteOff ptr 24 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM cIntToEnum    ((\ptr -> do {C2HSImp.peekByteOff ptr 32 :: IO C2HSImp.CInt}) p)
        <*> liftM id            ((\ptr -> do {C2HSImp.peekByteOff ptr 40 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM id            ((\ptr -> do {C2HSImp.peekByteOff ptr 48 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM id            ((\ptr -> do {C2HSImp.peekByteOff ptr 56 :: IO (C2HSImp.Ptr C2HSImp.CChar)}) p)
        <*> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 64 :: IO (C2HSImp.Ptr (RdKafkaGroupMemberInfoT))}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 72 :: IO C2HSImp.CInt}) p)
    poke p x = do
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 0 (val :: (C2HSImp.Ptr ()))})        p (castPtr      $ broker'RdKafkaGroupInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 24 (val :: (C2HSImp.Ptr C2HSImp.CChar))})         p (id           $ group'RdKafkaGroupInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 32 (val :: C2HSImp.CInt)})           p (enumToCInt   $ err'RdKafkaGroupInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 40 (val :: (C2HSImp.Ptr C2HSImp.CChar))})         p (id           $ state'RdKafkaGroupInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 48 (val :: (C2HSImp.Ptr C2HSImp.CChar))}) p (id           $ protocolType'RdKafkaGroupInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 56 (val :: (C2HSImp.Ptr C2HSImp.CChar))})      p (id           $ protocol'RdKafkaGroupInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 64 (val :: (C2HSImp.Ptr (RdKafkaGroupMemberInfoT)))})       p (castPtr      $ members'RdKafkaGroupInfoT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 72 (val :: C2HSImp.CInt)})    p (fromIntegral $ memberCnt'RdKafkaGroupInfoT x)

type RdKafkaGroupInfoTPtr = C2HSImp.ForeignPtr (RdKafkaGroupInfoT)
{-# LINE 596 "src/Kafka/Internal/RdKafka.chs" #-}


data RdKafkaGroupListT = RdKafkaGroupListT
    { groups'RdKafkaGroupListT   :: Ptr RdKafkaGroupInfoT
    , groupCnt'RdKafkaGroupListT :: Int }

instance Storable RdKafkaGroupListT where
    alignment _ = 8
{-# LINE 603 "src/Kafka/Internal/RdKafka.chs" #-}

    sizeOf _ = 16
{-# LINE 604 "src/Kafka/Internal/RdKafka.chs" #-}

    peek p = RdKafkaGroupListT
        <$> liftM castPtr       ((\ptr -> do {C2HSImp.peekByteOff ptr 0 :: IO (C2HSImp.Ptr (RdKafkaGroupInfoT))}) p)
        <*> liftM fromIntegral  ((\ptr -> do {C2HSImp.peekByteOff ptr 8 :: IO C2HSImp.CInt}) p)
    poke p x = do
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 0 (val :: (C2HSImp.Ptr (RdKafkaGroupInfoT)))})        p (castPtr      $ groups'RdKafkaGroupListT x)
      (\ptr val -> do {C2HSImp.pokeByteOff ptr 8 (val :: C2HSImp.CInt)})     p (fromIntegral $ groupCnt'RdKafkaGroupListT x)

type RdKafkaGroupListTPtr = C2HSImp.ForeignPtr (RdKafkaGroupListT)
{-# LINE 612 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaListGroups :: (RdKafkaTPtr) -> (String) -> (Ptr (Ptr RdKafkaGroupListT)) -> (Int) -> IO ((RdKafkaRespErrT))
rdKafkaListGroups a1 a2 a3 a4 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  let {a3' = castPtr a3} in 
  let {a4' = fromIntegral a4} in 
  rdKafkaListGroups'_ a1' a2' a3' a4' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 616 "src/Kafka/Internal/RdKafka.chs" #-}


foreign import ccall unsafe "rdkafka.h &rd_kafka_list_groups"
    rdKafkaGroupListDestroy :: FunPtr (Ptr RdKafkaGroupListT -> IO ())

-- listRdKafkaGroups :: RdKafkaTPtr -> String -> Int -> IO (Either RdKafkaRespErrT RdKafkaGroupListTPtr)
-- listRdKafkaGroups k g t = alloca $ \lstDblPtr -> do
--     err <- rdKafkaListGroups k g lstDblPtr t
--     case err of
--         RdKafkaRespErrNoError -> do
--             lstPtr <- peek lstDblPtr
--             lst    <- peek lstPtr
--             addForeignPtrFinalizer rdKafkaGroupListDestroy lstPtr
--             return $ Right lstPtr
--         e -> return $ Left e
-------------------------------------------------------------------------------------------------

-- rd_kafka_message
foreign import ccall unsafe "rdkafka.h &rd_kafka_message_destroy"
    rdKafkaMessageDestroyF :: FunPtr (Ptr RdKafkaMessageT -> IO ())

foreign import ccall unsafe "rdkafka.h rd_kafka_message_destroy"
    rdKafkaMessageDestroy :: Ptr RdKafkaMessageT -> IO ()

-- rd_kafka_conf
rdKafkaConfNew :: IO ((RdKafkaConfTPtr))
rdKafkaConfNew =
  rdKafkaConfNew'_ >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 642 "src/Kafka/Internal/RdKafka.chs" #-}


foreign import ccall unsafe "rdkafka.h &rd_kafka_conf_destroy"
    rdKafkaConfDestroy :: FunPtr (Ptr RdKafkaConfT -> IO ())

rdKafkaConfDup :: (RdKafkaConfTPtr) -> IO ((RdKafkaConfTPtr))
rdKafkaConfDup a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaConfDup'_ a1' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 648 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConfSet :: (RdKafkaConfTPtr) -> (String) -> (String) -> (CCharBufPointer) -> (CSize) -> IO ((RdKafkaConfResT))
rdKafkaConfSet a1 a2 a3 a4 a5 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  C2HSImp.withCString a3 $ \a3' -> 
  let {a4' = id a4} in 
  let {a5' = cIntConv a5} in 
  rdKafkaConfSet'_ a1' a2' a3' a4' a5' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 652 "src/Kafka/Internal/RdKafka.chs" #-}


newRdKafkaConfT :: IO RdKafkaConfTPtr
newRdKafkaConfT = do
    ret <- rdKafkaConfNew
    addForeignPtrFinalizer rdKafkaConfDestroy ret
    return ret

rdKafkaConfDump :: (RdKafkaConfTPtr) -> (CSizePtr) -> IO ((Ptr CString))
rdKafkaConfDump a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  rdKafkaConfDump'_ a1' a2' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 661 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConfDumpFree :: (Ptr CString) -> (CSize) -> IO ()
rdKafkaConfDumpFree a1 a2 =
  let {a1' = id a1} in 
  let {a2' = cIntConv a2} in 
  rdKafkaConfDumpFree'_ a1' a2' >>
  return ()

{-# LINE 664 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConfPropertiesShow :: (CFilePtr) -> IO ()
rdKafkaConfPropertiesShow a1 =
  let {a1' = id a1} in 
  rdKafkaConfPropertiesShow'_ a1' >>
  return ()

{-# LINE 667 "src/Kafka/Internal/RdKafka.chs" #-}


-- rd_kafka_topic_conf
rdKafkaTopicConfNew :: IO ((RdKafkaTopicConfTPtr))
rdKafkaTopicConfNew =
  rdKafkaTopicConfNew'_ >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 671 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaTopicConfDup :: (RdKafkaTopicConfTPtr) -> IO ((RdKafkaTopicConfTPtr))
rdKafkaTopicConfDup a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaTopicConfDup'_ a1' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 674 "src/Kafka/Internal/RdKafka.chs" #-}


foreign import ccall unsafe "rdkafka.h &rd_kafka_topic_conf_destroy"
    rdKafkaTopicConfDestroy :: FunPtr (Ptr RdKafkaTopicConfT -> IO ())

rdKafkaTopicConfSet :: (RdKafkaTopicConfTPtr) -> (String) -> (String) -> (CCharBufPointer) -> (CSize) -> IO ((RdKafkaConfResT))
rdKafkaTopicConfSet a1 a2 a3 a4 a5 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  C2HSImp.withCString a3 $ \a3' -> 
  let {a4' = id a4} in 
  let {a5' = cIntConv a5} in 
  rdKafkaTopicConfSet'_ a1' a2' a3' a4' a5' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 681 "src/Kafka/Internal/RdKafka.chs" #-}


newRdKafkaTopicConfT :: IO RdKafkaTopicConfTPtr
newRdKafkaTopicConfT = do
    ret <- rdKafkaTopicConfNew
    addForeignPtrFinalizer rdKafkaTopicConfDestroy ret
    return ret

rdKafkaTopicConfDump :: (RdKafkaTopicConfTPtr) -> (CSizePtr) -> IO ((Ptr CString))
rdKafkaTopicConfDump a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = castPtr a2} in 
  rdKafkaTopicConfDump'_ a1' a2' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 690 "src/Kafka/Internal/RdKafka.chs" #-}


-- rd_kafka
rdKafkaNew :: (RdKafkaTypeT) -> (RdKafkaConfTPtr) -> (CCharBufPointer) -> (CSize) -> IO ((RdKafkaTPtr))
rdKafkaNew a1 a2 a3 a4 =
  let {a1' = enumToCInt a1} in 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  let {a3' = id a3} in 
  let {a4' = cIntConv a4} in 
  rdKafkaNew'_ a1' a2' a3' a4' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 695 "src/Kafka/Internal/RdKafka.chs" #-}


foreign import ccall unsafe "rdkafka.h &rd_kafka_destroy"
    rdKafkaDestroy :: FunPtr (Ptr RdKafkaT -> IO ())

newRdKafkaT :: RdKafkaTypeT -> RdKafkaConfTPtr -> IO (Either String RdKafkaTPtr)
newRdKafkaT kafkaType confPtr =
    allocaBytes nErrorBytes $ \charPtr -> do
        duper <- rdKafkaConfDup confPtr
        ret <- rdKafkaNew kafkaType duper charPtr (fromIntegral nErrorBytes)
        withForeignPtr ret $ \realPtr -> do
            if realPtr == nullPtr then peekCString charPtr >>= return . Left
            else do
                addForeignPtrFinalizer rdKafkaDestroy ret
                return $ Right ret

rdKafkaBrokersAdd :: (RdKafkaTPtr) -> (String) -> IO ((Int))
rdKafkaBrokersAdd a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  rdKafkaBrokersAdd'_ a1' a2' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 712 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaSetLogLevel :: (RdKafkaTPtr) -> (Int) -> IO ()
rdKafkaSetLogLevel a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  rdKafkaSetLogLevel'_ a1' a2' >>
  return ()

{-# LINE 715 "src/Kafka/Internal/RdKafka.chs" #-}


-- rd_kafka consume

rdKafkaConsumeStartInternal :: (RdKafkaTopicTPtr) -> (CInt32T) -> (CInt64T) -> IO ((Int))
rdKafkaConsumeStartInternal a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  let {a3' = cIntConv a3} in 
  rdKafkaConsumeStartInternal'_ a1' a2' a3' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 720 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConsumeStart :: RdKafkaTopicTPtr -> Int -> Int64 -> IO (Maybe String)
rdKafkaConsumeStart topicPtr partition offset = do
    i <- rdKafkaConsumeStartInternal topicPtr (fromIntegral partition) (fromIntegral offset)
    case i of
        -1 -> kafkaErrnoString >>= return . Just
        _ -> return Nothing
rdKafkaConsumeStopInternal :: (RdKafkaTopicTPtr) -> (CInt32T) -> IO ((Int))
rdKafkaConsumeStopInternal a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  rdKafkaConsumeStopInternal'_ a1' a2' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 729 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConsume :: (RdKafkaTopicTPtr) -> (CInt32T) -> (Int) -> IO ((RdKafkaMessageTPtr))
rdKafkaConsume a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  let {a3' = fromIntegral a3} in 
  rdKafkaConsume'_ a1' a2' a3' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 732 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConsumeBatch :: (RdKafkaTopicTPtr) -> (CInt32T) -> (Int) -> (Ptr (Ptr RdKafkaMessageT)) -> (CSize) -> IO ((CSize))
rdKafkaConsumeBatch a1 a2 a3 a4 a5 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  let {a3' = fromIntegral a3} in 
  let {a4' = castPtr a4} in 
  let {a5' = cIntConv a5} in 
  rdKafkaConsumeBatch'_ a1' a2' a3' a4' a5' >>= \res ->
  let {res' = cIntConv res} in
  return (res')

{-# LINE 736 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaConsumeStop :: RdKafkaTopicTPtr -> Int -> IO (Maybe String)
rdKafkaConsumeStop topicPtr partition = do
    i <- rdKafkaConsumeStopInternal topicPtr (fromIntegral partition)
    case i of
        -1 -> kafkaErrnoString >>= return . Just
        _ -> return Nothing

rdKafkaOffsetStore :: (RdKafkaTopicTPtr) -> (CInt32T) -> (CInt64T) -> IO ((RdKafkaRespErrT))
rdKafkaOffsetStore a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  let {a3' = cIntConv a3} in 
  rdKafkaOffsetStore'_ a1' a2' a3' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 747 "src/Kafka/Internal/RdKafka.chs" #-}


-- rd_kafka produce

rdKafkaProduce :: (RdKafkaTopicTPtr) -> (CInt32T) -> (Int) -> (Word8Ptr) -> (CSize) -> (Word8Ptr) -> (CSize) -> (Word8Ptr) -> IO ((Int))
rdKafkaProduce a1 a2 a3 a4 a5 a6 a7 a8 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  let {a3' = fromIntegral a3} in 
  let {a4' = castPtr a4} in 
  let {a5' = cIntConv a5} in 
  let {a6' = castPtr a6} in 
  let {a7' = cIntConv a7} in 
  let {a8' = castPtr a8} in 
  rdKafkaProduce'_ a1' a2' a3' a4' a5' a6' a7' a8' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 754 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaProduceBatch :: (RdKafkaTopicTPtr) -> (CInt32T) -> (Int) -> (RdKafkaMessageTPtr) -> (Int) -> IO ((Int))
rdKafkaProduceBatch a1 a2 a3 a4 a5 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = cIntConv a2} in 
  let {a3' = fromIntegral a3} in 
  C2HSImp.withForeignPtr a4 $ \a4' -> 
  let {a5' = fromIntegral a5} in 
  rdKafkaProduceBatch'_ a1' a2' a3' a4' a5' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 757 "src/Kafka/Internal/RdKafka.chs" #-}


castMetadata :: Ptr (Ptr RdKafkaMetadataT) -> Ptr (Ptr ())
castMetadata ptr = castPtr ptr

-- rd_kafka_metadata

rdKafkaMetadata :: (RdKafkaTPtr) -> (Bool) -> (RdKafkaTopicTPtr) -> (Ptr (Ptr RdKafkaMetadataT)) -> (Int) -> IO ((RdKafkaRespErrT))
rdKafkaMetadata a1 a2 a3 a4 a5 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = boolToCInt a2} in 
  C2HSImp.withForeignPtr a3 $ \a3' -> 
  let {a4' = castMetadata a4} in 
  let {a5' = fromIntegral a5} in 
  rdKafkaMetadata'_ a1' a2' a3' a4' a5' >>= \res ->
  let {res' = cIntToEnum res} in
  return (res')

{-# LINE 767 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaMetadataDestroy :: (Ptr RdKafkaMetadataT) -> IO ()
rdKafkaMetadataDestroy a1 =
  let {a1' = castPtr a1} in 
  rdKafkaMetadataDestroy'_ a1' >>
  return ()

{-# LINE 770 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaPoll :: (RdKafkaTPtr) -> (Int) -> IO ((Int))
rdKafkaPoll a1 a2 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  rdKafkaPoll'_ a1' a2' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 773 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaOutqLen :: (RdKafkaTPtr) -> IO ((Int))
rdKafkaOutqLen a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaOutqLen'_ a1' >>= \res ->
  let {res' = fromIntegral res} in
  return (res')

{-# LINE 776 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaDump :: (CFilePtr) -> (RdKafkaTPtr) -> IO ()
rdKafkaDump a1 a2 =
  let {a1' = id a1} in 
  C2HSImp.withForeignPtr a2 $ \a2' -> 
  rdKafkaDump'_ a1' a2' >>
  return ()

{-# LINE 779 "src/Kafka/Internal/RdKafka.chs" #-}



-- rd_kafka_topic
rdKafkaTopicName :: (RdKafkaTopicTPtr) -> IO ((String))
rdKafkaTopicName a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  rdKafkaTopicName'_ a1' >>= \res ->
  C2HSImp.peekCString res >>= \res' ->
  return (res')

{-# LINE 784 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaTopicNew :: (RdKafkaTPtr) -> (String) -> (RdKafkaTopicConfTPtr) -> IO ((RdKafkaTopicTPtr))
rdKafkaTopicNew a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  C2HSImp.withCString a2 $ \a2' -> 
  C2HSImp.withForeignPtr a3 $ \a3' -> 
  rdKafkaTopicNew'_ a1' a2' a3' >>= \res ->
  C2HSImp.newForeignPtr_ res >>= \res' ->
  return (res')

{-# LINE 787 "src/Kafka/Internal/RdKafka.chs" #-}


rdKafkaTopicDestroy :: (Ptr RdKafkaTopicT) -> IO ()
rdKafkaTopicDestroy a1 =
  let {a1' = castPtr a1} in 
  rdKafkaTopicDestroy'_ a1' >>
  return ()

{-# LINE 790 "src/Kafka/Internal/RdKafka.chs" #-}


destroyUnmanagedRdKafkaTopic :: RdKafkaTopicTPtr -> IO ()
destroyUnmanagedRdKafkaTopic ptr =
  withForeignPtr ptr rdKafkaTopicDestroy

foreign import ccall unsafe "rdkafka.h &rd_kafka_topic_destroy"
    rdKafkaTopicDestroy' :: FunPtr (Ptr RdKafkaTopicT -> IO ())

newUnmanagedRdKafkaTopicT :: RdKafkaTPtr -> String -> RdKafkaTopicConfTPtr -> IO (Either String RdKafkaTopicTPtr)
newUnmanagedRdKafkaTopicT kafkaPtr topic topicConfPtr = do
    duper <- rdKafkaTopicConfDup topicConfPtr
    ret <- rdKafkaTopicNew kafkaPtr topic duper
    withForeignPtr ret $ \realPtr ->
        if realPtr == nullPtr then kafkaErrnoString >>= return . Left
        else return $ Right ret

newRdKafkaTopicT :: RdKafkaTPtr -> String -> RdKafkaTopicConfTPtr -> IO (Either String RdKafkaTopicTPtr)
newRdKafkaTopicT kafkaPtr topic topicConfPtr = do
    duper <- rdKafkaTopicConfDup topicConfPtr
    ret <- rdKafkaTopicNew kafkaPtr topic duper
    withForeignPtr ret $ \realPtr ->
        if realPtr == nullPtr then kafkaErrnoString >>= return . Left
        else do
            addForeignPtrFinalizer rdKafkaTopicDestroy' ret
            return $ Right ret

-- Marshall / Unmarshall
enumToCInt :: Enum a => a -> CInt
enumToCInt = fromIntegral . fromEnum
cIntToEnum :: Enum a => CInt -> a
cIntToEnum = toEnum . fromIntegral
cIntConv :: (Integral a, Num b) =>  a -> b
cIntConv = fromIntegral
boolToCInt :: Bool -> CInt
boolToCInt True = CInt 1
boolToCInt False = CInt 0

-- Handle -> File descriptor

foreign import ccall "" fdopen :: Fd -> CString -> IO (Ptr CFile)

handleToCFile :: Handle -> String -> IO (CFilePtr)
handleToCFile h m =
 do iomode <- newCString m
    fd <- handleToFd h
    fdopen fd iomode

c_stdin :: IO CFilePtr
c_stdin = handleToCFile stdin "r"
c_stdout :: IO CFilePtr
c_stdout = handleToCFile stdout "w"
c_stderr :: IO CFilePtr
c_stderr = handleToCFile stderr "w"

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_version"
  rdKafkaVersion'_ :: (IO C2HSImp.CInt)

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_version_str"
  rdKafkaVersionStr'_ :: (IO (C2HSImp.Ptr C2HSImp.CChar))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_err2str"
  rdKafkaErr2str'_ :: (C2HSImp.CInt -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_errno2err"
  rdKafkaErrno2err'_ :: (C2HSImp.CInt -> (IO C2HSImp.CInt))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_partition_list_new"
  rdKafkaTopicPartitionListNew'_ :: (C2HSImp.CInt -> (IO (C2HSImp.Ptr (RdKafkaTopicPartitionListT))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_partition_list_add"
  rdKafkaTopicPartitionListAdd'_ :: ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> (IO (C2HSImp.Ptr (RdKafkaTopicPartitionT))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_partition_list_add_range"
  rdKafkaTopicPartitionListAddRange'_ :: ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> (C2HSImp.CInt -> (IO ())))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_partition_list_copy"
  rdKafkaTopicPartitionListCopy'_ :: ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (IO (C2HSImp.Ptr (RdKafkaTopicPartitionListT))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_partition_list_set_offset"
  rdKafkaTopicPartitionListSetOffset'_ :: ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CInt -> (C2HSImp.CLLong -> (IO C2HSImp.CInt)))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_set_opaque"
  rdKafkaConfSetOpaque'_ :: ((C2HSImp.Ptr (RdKafkaConfT)) -> ((C2HSImp.Ptr ()) -> (IO ())))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_opaque"
  rdKafkaOpaque'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (IO (C2HSImp.Ptr ())))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_set_default_topic_conf"
  rdKafkaConfSetDefaultTopicConf'_ :: ((C2HSImp.Ptr (RdKafkaConfT)) -> ((C2HSImp.Ptr (RdKafkaTopicConfT)) -> (IO ())))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_partition_available"
  rdKafkaTopicPartitionAvailable'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_msg_partitioner_random"
  rdKafkaMsgPartitionerRandom'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> ((C2HSImp.Ptr ()) -> (C2HSImp.CULong -> (C2HSImp.CInt -> ((C2HSImp.Ptr ()) -> ((C2HSImp.Ptr ()) -> (IO C2HSImp.CInt)))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_msg_partitioner_consistent"
  rdKafkaMsgPartitionerConsistent'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> ((C2HSImp.Ptr ()) -> (C2HSImp.CULong -> (C2HSImp.CInt -> ((C2HSImp.Ptr ()) -> ((C2HSImp.Ptr ()) -> (IO C2HSImp.CInt)))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_msg_partitioner_consistent_random"
  rdKafkaMsgPartitionerConsistentRandom'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> ((C2HSImp.Ptr ()) -> (C2HSImp.CULong -> (C2HSImp.CInt -> ((C2HSImp.Ptr ()) -> ((C2HSImp.Ptr ()) -> (IO C2HSImp.CInt)))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_yield"
  rdKafkaYield'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (IO ()))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_pause_partitions"
  rdKafkaPausePartitions'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_resume_partitions"
  rdKafkaResumePartitions'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_queue_new"
  rdKafkaQueueNew'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (IO (C2HSImp.Ptr (RdKafkaQueueT))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_subscribe"
  rdKafkaSubscribe'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_unsubscribe"
  rdKafkaUnsubscribe'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (IO C2HSImp.CInt))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_subscription"
  rdKafkaSubscription'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (C2HSImp.Ptr (RdKafkaTopicPartitionListT))) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_consumer_poll"
  rdKafkaConsumerPoll'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (C2HSImp.CInt -> (IO (C2HSImp.Ptr (RdKafkaMessageT)))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_consumer_close"
  rdKafkaConsumerClose'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (IO C2HSImp.CInt))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_poll_set_consumer"
  rdKafkaPollSetConsumer'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (IO C2HSImp.CInt))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_assign"
  rdKafkaAssign'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_assignment"
  rdKafkaAssignment'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (C2HSImp.Ptr (RdKafkaTopicPartitionListT))) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_commit"
  rdKafkaCommit'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_commit_message"
  rdKafkaCommitMessage'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaMessageT)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_committed"
  rdKafkaCommitted'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_position"
  rdKafkaPosition'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr (RdKafkaTopicPartitionListT)) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_list_groups"
  rdKafkaListGroups'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr (C2HSImp.Ptr (RdKafkaGroupListT))) -> (C2HSImp.CInt -> (IO C2HSImp.CInt)))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_new"
  rdKafkaConfNew'_ :: (IO (C2HSImp.Ptr (RdKafkaConfT)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_dup"
  rdKafkaConfDup'_ :: ((C2HSImp.Ptr (RdKafkaConfT)) -> (IO (C2HSImp.Ptr (RdKafkaConfT))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_set"
  rdKafkaConfSet'_ :: ((C2HSImp.Ptr (RdKafkaConfT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CULong -> (IO C2HSImp.CInt))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_dump"
  rdKafkaConfDump'_ :: ((C2HSImp.Ptr (RdKafkaConfT)) -> ((C2HSImp.Ptr C2HSImp.CULong) -> (IO (C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_dump_free"
  rdKafkaConfDumpFree'_ :: ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (C2HSImp.CULong -> (IO ())))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_conf_properties_show"
  rdKafkaConfPropertiesShow'_ :: ((CFilePtr) -> (IO ()))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_conf_new"
  rdKafkaTopicConfNew'_ :: (IO (C2HSImp.Ptr (RdKafkaTopicConfT)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_conf_dup"
  rdKafkaTopicConfDup'_ :: ((C2HSImp.Ptr (RdKafkaTopicConfT)) -> (IO (C2HSImp.Ptr (RdKafkaTopicConfT))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_conf_set"
  rdKafkaTopicConfSet'_ :: ((C2HSImp.Ptr (RdKafkaTopicConfT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CULong -> (IO C2HSImp.CInt))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_conf_dump"
  rdKafkaTopicConfDump'_ :: ((C2HSImp.Ptr (RdKafkaTopicConfT)) -> ((C2HSImp.Ptr C2HSImp.CULong) -> (IO (C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_new"
  rdKafkaNew'_ :: (C2HSImp.CInt -> ((C2HSImp.Ptr (RdKafkaConfT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (C2HSImp.CULong -> (IO (C2HSImp.Ptr (RdKafkaT)))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_brokers_add"
  rdKafkaBrokersAdd'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_set_log_level"
  rdKafkaSetLogLevel'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (C2HSImp.CInt -> (IO ())))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_consume_start"
  rdKafkaConsumeStartInternal'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (C2HSImp.CLLong -> (IO C2HSImp.CInt))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_consume_stop"
  rdKafkaConsumeStopInternal'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_consume"
  rdKafkaConsume'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (C2HSImp.CInt -> (IO (C2HSImp.Ptr (RdKafkaMessageT))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_consume_batch"
  rdKafkaConsumeBatch'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (C2HSImp.CInt -> ((C2HSImp.Ptr (C2HSImp.Ptr (RdKafkaMessageT))) -> (C2HSImp.CULong -> (IO C2HSImp.CLong))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_offset_store"
  rdKafkaOffsetStore'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (C2HSImp.CLLong -> (IO C2HSImp.CInt))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_produce"
  rdKafkaProduce'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (C2HSImp.CInt -> ((C2HSImp.Ptr ()) -> (C2HSImp.CULong -> ((C2HSImp.Ptr ()) -> (C2HSImp.CULong -> ((C2HSImp.Ptr ()) -> (IO C2HSImp.CInt)))))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_produce_batch"
  rdKafkaProduceBatch'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (C2HSImp.CInt -> (C2HSImp.CInt -> ((C2HSImp.Ptr (RdKafkaMessageT)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_metadata"
  rdKafkaMetadata'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (C2HSImp.CInt -> ((C2HSImp.Ptr (RdKafkaTopicT)) -> ((C2HSImp.Ptr (C2HSImp.Ptr ())) -> (C2HSImp.CInt -> (IO C2HSImp.CInt))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_metadata_destroy"
  rdKafkaMetadataDestroy'_ :: ((C2HSImp.Ptr ()) -> (IO ()))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_poll"
  rdKafkaPoll'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (C2HSImp.CInt -> (IO C2HSImp.CInt)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_outq_len"
  rdKafkaOutqLen'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> (IO C2HSImp.CInt))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_dump"
  rdKafkaDump'_ :: ((CFilePtr) -> ((C2HSImp.Ptr (RdKafkaT)) -> (IO ())))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_name"
  rdKafkaTopicName'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_new"
  rdKafkaTopicNew'_ :: ((C2HSImp.Ptr (RdKafkaT)) -> ((C2HSImp.Ptr C2HSImp.CChar) -> ((C2HSImp.Ptr (RdKafkaTopicConfT)) -> (IO (C2HSImp.Ptr (RdKafkaTopicT))))))

foreign import ccall safe "Kafka/Internal/RdKafka.chs.h rd_kafka_topic_destroy"
  rdKafkaTopicDestroy'_ :: ((C2HSImp.Ptr (RdKafkaTopicT)) -> (IO ()))