{-# LINE 1 "Bindings/Libgit2/RefdbBackend.hsc" #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# LINE 2 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 3 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 4 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 5 "Bindings/Libgit2/RefdbBackend.hsc" #-}
module Bindings.Libgit2.RefdbBackend where
import Foreign.Ptr
import Foreign.Ptr (Ptr,FunPtr,plusPtr)
import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)
import Foreign.Storable
import Foreign.C.Types
import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)
import Foreign.Marshal.Alloc (alloca)
import Foreign.Marshal.Array (peekArray,pokeArray)
import Data.Int
import Data.Word

{-# LINE 8 "Bindings/Libgit2/RefdbBackend.hsc" #-}

import Bindings.Libgit2.Common
import Bindings.Libgit2.Types
import Bindings.Libgit2.Refs
import Bindings.Libgit2.Oid
{- struct git_refdb_backend {
    unsigned int version;
    int (* exists)(int * exists,
                   struct git_refdb_backend * backend,
                   const char * ref_name);
    int (* lookup)(git_reference * * out,
                   struct git_refdb_backend * backend,
                   const char * ref_name);
    int (* foreach)(struct git_refdb_backend * backend,
                    unsigned int list_flags,
                    git_reference_foreach_cb callback,
                    void * payload);
    int (* foreach_glob)(struct git_refdb_backend * backend,
                         const char * glob,
                         unsigned int list_flags,
                         git_reference_foreach_cb callback,
                         void * payload);
    int (* write)(struct git_refdb_backend * backend,
                  const git_reference * ref);
    int (* delete)(struct git_refdb_backend * backend,
                   const git_reference * ref);
    int (* compress)(struct git_refdb_backend * backend);
    void (* free)(struct git_refdb_backend * backend);
}; -}
type C'git_refdb_backend_exists_callback = FunPtr (Ptr CInt -> Ptr C'git_refdb_backend -> CString -> IO CInt)
foreign import ccall "wrapper" mk'git_refdb_backend_exists_callback
  :: (Ptr CInt -> Ptr C'git_refdb_backend -> CString -> IO CInt) -> IO C'git_refdb_backend_exists_callback
foreign import ccall "dynamic" mK'git_refdb_backend_exists_callback
  :: C'git_refdb_backend_exists_callback -> (Ptr CInt -> Ptr C'git_refdb_backend -> CString -> IO CInt)

{-# LINE 38 "Bindings/Libgit2/RefdbBackend.hsc" #-}
type C'git_refdb_backend_lookup_callback = FunPtr (Ptr (Ptr C'git_reference) -> Ptr C'git_refdb_backend -> CString -> IO CInt)
foreign import ccall "wrapper" mk'git_refdb_backend_lookup_callback
  :: (Ptr (Ptr C'git_reference) -> Ptr C'git_refdb_backend -> CString -> IO CInt) -> IO C'git_refdb_backend_lookup_callback
foreign import ccall "dynamic" mK'git_refdb_backend_lookup_callback
  :: C'git_refdb_backend_lookup_callback -> (Ptr (Ptr C'git_reference) -> Ptr C'git_refdb_backend -> CString -> IO CInt)

{-# LINE 39 "Bindings/Libgit2/RefdbBackend.hsc" #-}
type C'git_refdb_backend_foreach_callback = FunPtr (Ptr C'git_refdb_backend -> CUInt -> C'git_reference_foreach_cb -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_refdb_backend_foreach_callback
  :: (Ptr C'git_refdb_backend -> CUInt -> C'git_reference_foreach_cb -> Ptr () -> IO CInt) -> IO C'git_refdb_backend_foreach_callback
foreign import ccall "dynamic" mK'git_refdb_backend_foreach_callback
  :: C'git_refdb_backend_foreach_callback -> (Ptr C'git_refdb_backend -> CUInt -> C'git_reference_foreach_cb -> Ptr () -> IO CInt)

{-# LINE 40 "Bindings/Libgit2/RefdbBackend.hsc" #-}
type C'git_refdb_backend_foreach_glob_callback = FunPtr (Ptr C'git_refdb_backend -> CString -> CUInt -> C'git_reference_foreach_cb -> Ptr () -> IO CInt)
foreign import ccall "wrapper" mk'git_refdb_backend_foreach_glob_callback
  :: (Ptr C'git_refdb_backend -> CString -> CUInt -> C'git_reference_foreach_cb -> Ptr () -> IO CInt) -> IO C'git_refdb_backend_foreach_glob_callback
foreign import ccall "dynamic" mK'git_refdb_backend_foreach_glob_callback
  :: C'git_refdb_backend_foreach_glob_callback -> (Ptr C'git_refdb_backend -> CString -> CUInt -> C'git_reference_foreach_cb -> Ptr () -> IO CInt)

{-# LINE 41 "Bindings/Libgit2/RefdbBackend.hsc" #-}
type C'git_refdb_backend_write_callback = FunPtr (Ptr C'git_refdb_backend -> Ptr C'git_reference -> IO CInt)
foreign import ccall "wrapper" mk'git_refdb_backend_write_callback
  :: (Ptr C'git_refdb_backend -> Ptr C'git_reference -> IO CInt) -> IO C'git_refdb_backend_write_callback
foreign import ccall "dynamic" mK'git_refdb_backend_write_callback
  :: C'git_refdb_backend_write_callback -> (Ptr C'git_refdb_backend -> Ptr C'git_reference -> IO CInt)

{-# LINE 42 "Bindings/Libgit2/RefdbBackend.hsc" #-}
type C'git_refdb_backend_delete_callback = FunPtr (Ptr C'git_refdb_backend -> Ptr C'git_reference -> IO CInt)
foreign import ccall "wrapper" mk'git_refdb_backend_delete_callback
  :: (Ptr C'git_refdb_backend -> Ptr C'git_reference -> IO CInt) -> IO C'git_refdb_backend_delete_callback
foreign import ccall "dynamic" mK'git_refdb_backend_delete_callback
  :: C'git_refdb_backend_delete_callback -> (Ptr C'git_refdb_backend -> Ptr C'git_reference -> IO CInt)

{-# LINE 43 "Bindings/Libgit2/RefdbBackend.hsc" #-}
type C'git_refdb_backend_compress_callback = FunPtr (Ptr C'git_refdb_backend -> IO CInt)
foreign import ccall "wrapper" mk'git_refdb_backend_compress_callback
  :: (Ptr C'git_refdb_backend -> IO CInt) -> IO C'git_refdb_backend_compress_callback
foreign import ccall "dynamic" mK'git_refdb_backend_compress_callback
  :: C'git_refdb_backend_compress_callback -> (Ptr C'git_refdb_backend -> IO CInt)

{-# LINE 44 "Bindings/Libgit2/RefdbBackend.hsc" #-}
type C'git_refdb_backend_free_callback = FunPtr (Ptr C'git_refdb_backend -> IO ())
foreign import ccall "wrapper" mk'git_refdb_backend_free_callback
  :: (Ptr C'git_refdb_backend -> IO ()) -> IO C'git_refdb_backend_free_callback
foreign import ccall "dynamic" mK'git_refdb_backend_free_callback
  :: C'git_refdb_backend_free_callback -> (Ptr C'git_refdb_backend -> IO ())

{-# LINE 45 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 46 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 47 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 48 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 49 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 50 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 51 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 52 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 53 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 54 "Bindings/Libgit2/RefdbBackend.hsc" #-}

{-# LINE 55 "Bindings/Libgit2/RefdbBackend.hsc" #-}
data C'git_refdb_backend = C'git_refdb_backend{
  c'git_refdb_backend'version :: CUInt,
  c'git_refdb_backend'exists :: C'git_refdb_backend_exists_callback,
  c'git_refdb_backend'lookup :: C'git_refdb_backend_lookup_callback,
  c'git_refdb_backend'foreach :: C'git_refdb_backend_foreach_callback,
  c'git_refdb_backend'foreach_glob :: C'git_refdb_backend_foreach_glob_callback,
  c'git_refdb_backend'write :: C'git_refdb_backend_write_callback,
  c'git_refdb_backend'delete :: C'git_refdb_backend_delete_callback,
  c'git_refdb_backend'compress :: C'git_refdb_backend_compress_callback,
  c'git_refdb_backend'free :: C'git_refdb_backend_free_callback
} deriving (Eq,Show)
p'git_refdb_backend'version p = plusPtr p 0
p'git_refdb_backend'version :: Ptr (C'git_refdb_backend) -> Ptr (CUInt)
p'git_refdb_backend'exists p = plusPtr p 8
p'git_refdb_backend'exists :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_exists_callback)
p'git_refdb_backend'lookup p = plusPtr p 16
p'git_refdb_backend'lookup :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_lookup_callback)
p'git_refdb_backend'foreach p = plusPtr p 24
p'git_refdb_backend'foreach :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_foreach_callback)
p'git_refdb_backend'foreach_glob p = plusPtr p 32
p'git_refdb_backend'foreach_glob :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_foreach_glob_callback)
p'git_refdb_backend'write p = plusPtr p 40
p'git_refdb_backend'write :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_write_callback)
p'git_refdb_backend'delete p = plusPtr p 48
p'git_refdb_backend'delete :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_delete_callback)
p'git_refdb_backend'compress p = plusPtr p 56
p'git_refdb_backend'compress :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_compress_callback)
p'git_refdb_backend'free p = plusPtr p 64
p'git_refdb_backend'free :: Ptr (C'git_refdb_backend) -> Ptr (C'git_refdb_backend_free_callback)
instance Storable C'git_refdb_backend where
  sizeOf _ = 72
  alignment _ = 8
  peek p = do
    v0 <- peekByteOff p 0
    v1 <- peekByteOff p 8
    v2 <- peekByteOff p 16
    v3 <- peekByteOff p 24
    v4 <- peekByteOff p 32
    v5 <- peekByteOff p 40
    v6 <- peekByteOff p 48
    v7 <- peekByteOff p 56
    v8 <- peekByteOff p 64
    return $ C'git_refdb_backend v0 v1 v2 v3 v4 v5 v6 v7 v8
  poke p (C'git_refdb_backend v0 v1 v2 v3 v4 v5 v6 v7 v8) = do
    pokeByteOff p 0 v0
    pokeByteOff p 8 v1
    pokeByteOff p 16 v2
    pokeByteOff p 24 v3
    pokeByteOff p 32 v4
    pokeByteOff p 40 v5
    pokeByteOff p 48 v6
    pokeByteOff p 56 v7
    pokeByteOff p 64 v8
    return ()

{-# LINE 56 "Bindings/Libgit2/RefdbBackend.hsc" #-}
foreign import ccall "git_refdb_backend_fs" c'git_refdb_backend_fs
  :: Ptr (Ptr C'git_refdb_backend) -> Ptr C'git_repository -> Ptr C'git_refdb -> IO (CInt)
foreign import ccall "&git_refdb_backend_fs" p'git_refdb_backend_fs
  :: FunPtr (Ptr (Ptr C'git_refdb_backend) -> Ptr C'git_repository -> Ptr C'git_refdb -> IO (CInt))

{-# LINE 57 "Bindings/Libgit2/RefdbBackend.hsc" #-}