{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a diff binary file.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Ggit.Structs.DiffBinaryFile
    ( 

-- * Exported types
    DiffBinaryFile(..)                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [ref]("GI.Ggit.Structs.DiffBinaryFile#g:method:ref"), [unref]("GI.Ggit.Structs.DiffBinaryFile#g:method:unref").
-- 
-- ==== Getters
-- [getBinaryType]("GI.Ggit.Structs.DiffBinaryFile#g:method:getBinaryType"), [getData]("GI.Ggit.Structs.DiffBinaryFile#g:method:getData"), [getInflatedSize]("GI.Ggit.Structs.DiffBinaryFile#g:method:getInflatedSize").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveDiffBinaryFileMethod             ,
#endif

-- ** getBinaryType #method:getBinaryType#

#if defined(ENABLE_OVERLOADING)
    DiffBinaryFileGetBinaryTypeMethodInfo   ,
#endif
    diffBinaryFileGetBinaryType             ,


-- ** getData #method:getData#

#if defined(ENABLE_OVERLOADING)
    DiffBinaryFileGetDataMethodInfo         ,
#endif
    diffBinaryFileGetData                   ,


-- ** getInflatedSize #method:getInflatedSize#

#if defined(ENABLE_OVERLOADING)
    DiffBinaryFileGetInflatedSizeMethodInfo ,
#endif
    diffBinaryFileGetInflatedSize           ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    DiffBinaryFileRefMethodInfo             ,
#endif
    diffBinaryFileRef                       ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    DiffBinaryFileUnrefMethodInfo           ,
#endif
    diffBinaryFileUnref                     ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums

-- | Memory-managed wrapper type.
newtype DiffBinaryFile = DiffBinaryFile (SP.ManagedPtr DiffBinaryFile)
    deriving (DiffBinaryFile -> DiffBinaryFile -> Bool
(DiffBinaryFile -> DiffBinaryFile -> Bool)
-> (DiffBinaryFile -> DiffBinaryFile -> Bool) -> Eq DiffBinaryFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffBinaryFile -> DiffBinaryFile -> Bool
$c/= :: DiffBinaryFile -> DiffBinaryFile -> Bool
== :: DiffBinaryFile -> DiffBinaryFile -> Bool
$c== :: DiffBinaryFile -> DiffBinaryFile -> Bool
Eq)

instance SP.ManagedPtrNewtype DiffBinaryFile where
    toManagedPtr :: DiffBinaryFile -> ManagedPtr DiffBinaryFile
toManagedPtr (DiffBinaryFile ManagedPtr DiffBinaryFile
p) = ManagedPtr DiffBinaryFile
p

foreign import ccall "ggit_diff_binary_file_get_type" c_ggit_diff_binary_file_get_type :: 
    IO GType

type instance O.ParentTypes DiffBinaryFile = '[]
instance O.HasParentTypes DiffBinaryFile

instance B.Types.TypedObject DiffBinaryFile where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_binary_file_get_type

instance B.Types.GBoxed DiffBinaryFile

-- | Convert 'DiffBinaryFile' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe DiffBinaryFile) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_diff_binary_file_get_type
    gvalueSet_ :: Ptr GValue -> Maybe DiffBinaryFile -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DiffBinaryFile
P.Nothing = Ptr GValue -> Ptr DiffBinaryFile -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr DiffBinaryFile
forall a. Ptr a
FP.nullPtr :: FP.Ptr DiffBinaryFile)
    gvalueSet_ Ptr GValue
gv (P.Just DiffBinaryFile
obj) = DiffBinaryFile -> (Ptr DiffBinaryFile -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DiffBinaryFile
obj (Ptr GValue -> Ptr DiffBinaryFile -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe DiffBinaryFile)
gvalueGet_ Ptr GValue
gv = do
        Ptr DiffBinaryFile
ptr <- Ptr GValue -> IO (Ptr DiffBinaryFile)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr DiffBinaryFile)
        if Ptr DiffBinaryFile
ptr Ptr DiffBinaryFile -> Ptr DiffBinaryFile -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DiffBinaryFile
forall a. Ptr a
FP.nullPtr
        then DiffBinaryFile -> Maybe DiffBinaryFile
forall a. a -> Maybe a
P.Just (DiffBinaryFile -> Maybe DiffBinaryFile)
-> IO DiffBinaryFile -> IO (Maybe DiffBinaryFile)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DiffBinaryFile -> DiffBinaryFile)
-> Ptr DiffBinaryFile -> IO DiffBinaryFile
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr DiffBinaryFile -> DiffBinaryFile
DiffBinaryFile Ptr DiffBinaryFile
ptr
        else Maybe DiffBinaryFile -> IO (Maybe DiffBinaryFile)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiffBinaryFile
forall a. Maybe a
P.Nothing
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DiffBinaryFile
type instance O.AttributeList DiffBinaryFile = DiffBinaryFileAttributeList
type DiffBinaryFileAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method DiffBinaryFile::get_binary_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "file"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "DiffBinaryFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitDiffBinaryFile."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "DiffBinaryType" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_diff_binary_file_get_binary_type" ggit_diff_binary_file_get_binary_type :: 
    Ptr DiffBinaryFile ->                   -- file : TInterface (Name {namespace = "Ggit", name = "DiffBinaryFile"})
    IO CUInt

-- | Gets the t'GI.Ggit.Enums.DiffBinaryType' for /@file@/.
diffBinaryFileGetBinaryType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DiffBinaryFile
    -- ^ /@file@/: a t'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'.
    -> m Ggit.Enums.DiffBinaryType
    -- ^ __Returns:__ the file\'s binary type.
diffBinaryFileGetBinaryType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DiffBinaryFile -> m DiffBinaryType
diffBinaryFileGetBinaryType DiffBinaryFile
file = IO DiffBinaryType -> m DiffBinaryType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiffBinaryType -> m DiffBinaryType)
-> IO DiffBinaryType -> m DiffBinaryType
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiffBinaryFile
file' <- DiffBinaryFile -> IO (Ptr DiffBinaryFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffBinaryFile
file
    CUInt
result <- Ptr DiffBinaryFile -> IO CUInt
ggit_diff_binary_file_get_binary_type Ptr DiffBinaryFile
file'
    let result' :: DiffBinaryType
result' = (Int -> DiffBinaryType
forall a. Enum a => Int -> a
toEnum (Int -> DiffBinaryType)
-> (CUInt -> Int) -> CUInt -> DiffBinaryType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    DiffBinaryFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffBinaryFile
file
    DiffBinaryType -> IO DiffBinaryType
forall (m :: * -> *) a. Monad m => a -> m a
return DiffBinaryType
result'

#if defined(ENABLE_OVERLOADING)
data DiffBinaryFileGetBinaryTypeMethodInfo
instance (signature ~ (m Ggit.Enums.DiffBinaryType), MonadIO m) => O.OverloadedMethod DiffBinaryFileGetBinaryTypeMethodInfo DiffBinaryFile signature where
    overloadedMethod = diffBinaryFileGetBinaryType

instance O.OverloadedMethodInfo DiffBinaryFileGetBinaryTypeMethodInfo DiffBinaryFile where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.DiffBinaryFile.diffBinaryFileGetBinaryType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-DiffBinaryFile.html#v:diffBinaryFileGetBinaryType"
        })


#endif

-- method DiffBinaryFile::get_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "file"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "DiffBinaryFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitDiffBinaryFile."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to return size of byte data."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt8)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_diff_binary_file_get_data" ggit_diff_binary_file_get_data :: 
    Ptr DiffBinaryFile ->                   -- file : TInterface (Name {namespace = "Ggit", name = "DiffBinaryFile"})
    Word64 ->                               -- size : TBasicType TUInt64
    IO Word8

-- | Get the binary data. This data should not be modified.
diffBinaryFileGetData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DiffBinaryFile
    -- ^ /@file@/: a t'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'.
    -> Word64
    -- ^ /@size@/: location to return size of byte data.
    -> m Word8
    -- ^ __Returns:__ a pointer to the binary data, or 'P.Nothing'.
diffBinaryFileGetData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DiffBinaryFile -> Word64 -> m Word8
diffBinaryFileGetData DiffBinaryFile
file Word64
size = IO Word8 -> m Word8
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiffBinaryFile
file' <- DiffBinaryFile -> IO (Ptr DiffBinaryFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffBinaryFile
file
    Word8
result <- Ptr DiffBinaryFile -> Word64 -> IO Word8
ggit_diff_binary_file_get_data Ptr DiffBinaryFile
file' Word64
size
    DiffBinaryFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffBinaryFile
file
    Word8 -> IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result

#if defined(ENABLE_OVERLOADING)
data DiffBinaryFileGetDataMethodInfo
instance (signature ~ (Word64 -> m Word8), MonadIO m) => O.OverloadedMethod DiffBinaryFileGetDataMethodInfo DiffBinaryFile signature where
    overloadedMethod = diffBinaryFileGetData

instance O.OverloadedMethodInfo DiffBinaryFileGetDataMethodInfo DiffBinaryFile where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.DiffBinaryFile.diffBinaryFileGetData",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-DiffBinaryFile.html#v:diffBinaryFileGetData"
        })


#endif

-- method DiffBinaryFile::get_inflated_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "file"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "DiffBinaryFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitDiffBinaryFile."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_diff_binary_file_get_inflated_size" ggit_diff_binary_file_get_inflated_size :: 
    Ptr DiffBinaryFile ->                   -- file : TInterface (Name {namespace = "Ggit", name = "DiffBinaryFile"})
    IO Word64

-- | Gets the length of the binary data after inflation.
diffBinaryFileGetInflatedSize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DiffBinaryFile
    -- ^ /@file@/: a t'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'.
    -> m Word64
    -- ^ __Returns:__ the length of the binary data after inflation.
diffBinaryFileGetInflatedSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DiffBinaryFile -> m Word64
diffBinaryFileGetInflatedSize DiffBinaryFile
file = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiffBinaryFile
file' <- DiffBinaryFile -> IO (Ptr DiffBinaryFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffBinaryFile
file
    Word64
result <- Ptr DiffBinaryFile -> IO Word64
ggit_diff_binary_file_get_inflated_size Ptr DiffBinaryFile
file'
    DiffBinaryFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffBinaryFile
file
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data DiffBinaryFileGetInflatedSizeMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.OverloadedMethod DiffBinaryFileGetInflatedSizeMethodInfo DiffBinaryFile signature where
    overloadedMethod = diffBinaryFileGetInflatedSize

instance O.OverloadedMethodInfo DiffBinaryFileGetInflatedSizeMethodInfo DiffBinaryFile where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.DiffBinaryFile.diffBinaryFileGetInflatedSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-DiffBinaryFile.html#v:diffBinaryFileGetInflatedSize"
        })


#endif

-- method DiffBinaryFile::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "file"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "DiffBinaryFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitDiff." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "DiffBinaryFile" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_diff_binary_file_ref" ggit_diff_binary_file_ref :: 
    Ptr DiffBinaryFile ->                   -- file : TInterface (Name {namespace = "Ggit", name = "DiffBinaryFile"})
    IO (Ptr DiffBinaryFile)

-- | Atomically increments the reference count of /@file@/ by one.
-- This function is MT-safe and may be called from any thread.
diffBinaryFileRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DiffBinaryFile
    -- ^ /@file@/: a t'GI.Ggit.Objects.Diff.Diff'.
    -> m DiffBinaryFile
    -- ^ __Returns:__ a t'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'.
diffBinaryFileRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DiffBinaryFile -> m DiffBinaryFile
diffBinaryFileRef DiffBinaryFile
file = IO DiffBinaryFile -> m DiffBinaryFile
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiffBinaryFile -> m DiffBinaryFile)
-> IO DiffBinaryFile -> m DiffBinaryFile
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiffBinaryFile
file' <- DiffBinaryFile -> IO (Ptr DiffBinaryFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffBinaryFile
file
    Ptr DiffBinaryFile
result <- Ptr DiffBinaryFile -> IO (Ptr DiffBinaryFile)
ggit_diff_binary_file_ref Ptr DiffBinaryFile
file'
    Text -> Ptr DiffBinaryFile -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"diffBinaryFileRef" Ptr DiffBinaryFile
result
    DiffBinaryFile
result' <- ((ManagedPtr DiffBinaryFile -> DiffBinaryFile)
-> Ptr DiffBinaryFile -> IO DiffBinaryFile
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DiffBinaryFile -> DiffBinaryFile
DiffBinaryFile) Ptr DiffBinaryFile
result
    DiffBinaryFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffBinaryFile
file
    DiffBinaryFile -> IO DiffBinaryFile
forall (m :: * -> *) a. Monad m => a -> m a
return DiffBinaryFile
result'

#if defined(ENABLE_OVERLOADING)
data DiffBinaryFileRefMethodInfo
instance (signature ~ (m DiffBinaryFile), MonadIO m) => O.OverloadedMethod DiffBinaryFileRefMethodInfo DiffBinaryFile signature where
    overloadedMethod = diffBinaryFileRef

instance O.OverloadedMethodInfo DiffBinaryFileRefMethodInfo DiffBinaryFile where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.DiffBinaryFile.diffBinaryFileRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-DiffBinaryFile.html#v:diffBinaryFileRef"
        })


#endif

-- method DiffBinaryFile::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "file"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "DiffBinaryFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitDiffBinaryFile."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_diff_binary_file_unref" ggit_diff_binary_file_unref :: 
    Ptr DiffBinaryFile ->                   -- file : TInterface (Name {namespace = "Ggit", name = "DiffBinaryFile"})
    IO ()

-- | Atomically decrements the reference count of /@file@/ by one.
-- If the reference count drops to 0, /@file@/ is freed.
diffBinaryFileUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DiffBinaryFile
    -- ^ /@file@/: a t'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'.
    -> m ()
diffBinaryFileUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DiffBinaryFile -> m ()
diffBinaryFileUnref DiffBinaryFile
file = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiffBinaryFile
file' <- DiffBinaryFile -> IO (Ptr DiffBinaryFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffBinaryFile
file
    Ptr DiffBinaryFile -> IO ()
ggit_diff_binary_file_unref Ptr DiffBinaryFile
file'
    DiffBinaryFile -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffBinaryFile
file
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DiffBinaryFileUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DiffBinaryFileUnrefMethodInfo DiffBinaryFile signature where
    overloadedMethod = diffBinaryFileUnref

instance O.OverloadedMethodInfo DiffBinaryFileUnrefMethodInfo DiffBinaryFile where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.DiffBinaryFile.diffBinaryFileUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-DiffBinaryFile.html#v:diffBinaryFileUnref"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveDiffBinaryFileMethod (t :: Symbol) (o :: *) :: * where
    ResolveDiffBinaryFileMethod "ref" o = DiffBinaryFileRefMethodInfo
    ResolveDiffBinaryFileMethod "unref" o = DiffBinaryFileUnrefMethodInfo
    ResolveDiffBinaryFileMethod "getBinaryType" o = DiffBinaryFileGetBinaryTypeMethodInfo
    ResolveDiffBinaryFileMethod "getData" o = DiffBinaryFileGetDataMethodInfo
    ResolveDiffBinaryFileMethod "getInflatedSize" o = DiffBinaryFileGetInflatedSizeMethodInfo
    ResolveDiffBinaryFileMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDiffBinaryFileMethod t DiffBinaryFile, O.OverloadedMethod info DiffBinaryFile p) => OL.IsLabel t (DiffBinaryFile -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDiffBinaryFileMethod t DiffBinaryFile, O.OverloadedMethod info DiffBinaryFile p, R.HasField t DiffBinaryFile p) => R.HasField t DiffBinaryFile p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveDiffBinaryFileMethod t DiffBinaryFile, O.OverloadedMethodInfo info DiffBinaryFile) => OL.IsLabel t (O.MethodProxy info DiffBinaryFile) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif