#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Ggit.Objects.Blame
(
Blame(..) ,
IsBlame ,
toBlame ,
noBlame ,
#if ENABLE_OVERLOADING
BlameFromBufferMethodInfo ,
#endif
blameFromBuffer ,
blameGetFlags ,
#if ENABLE_OVERLOADING
BlameGetHunkByIndexMethodInfo ,
#endif
blameGetHunkByIndex ,
#if ENABLE_OVERLOADING
BlameGetHunkByLineMethodInfo ,
#endif
blameGetHunkByLine ,
#if ENABLE_OVERLOADING
BlameGetHunkCountMethodInfo ,
#endif
blameGetHunkCount ,
blameSetFlags ,
) 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.ManagedPtr as B.ManagedPtr
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.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags
import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Structs.BlameHunk as Ggit.BlameHunk
import {-# SOURCE #-} qualified GI.Ggit.Structs.BlameOptions as Ggit.BlameOptions
newtype Blame = Blame (ManagedPtr Blame)
foreign import ccall "ggit_blame_get_type"
c_ggit_blame_get_type :: IO GType
instance GObject Blame where
gobjectType = c_ggit_blame_get_type
class (GObject o, O.IsDescendantOf Blame o) => IsBlame o
instance (GObject o, O.IsDescendantOf Blame o) => IsBlame o
instance O.HasParentTypes Blame
type instance O.ParentTypes Blame = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]
toBlame :: (MonadIO m, IsBlame o) => o -> m Blame
toBlame = liftIO . unsafeCastTo Blame
noBlame :: Maybe Blame
noBlame = Nothing
#if ENABLE_OVERLOADING
type family ResolveBlameMethod (t :: Symbol) (o :: *) :: * where
ResolveBlameMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveBlameMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveBlameMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveBlameMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveBlameMethod "fromBuffer" o = BlameFromBufferMethodInfo
ResolveBlameMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveBlameMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveBlameMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveBlameMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveBlameMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveBlameMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveBlameMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveBlameMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveBlameMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveBlameMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveBlameMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveBlameMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveBlameMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveBlameMethod "getHunkByIndex" o = BlameGetHunkByIndexMethodInfo
ResolveBlameMethod "getHunkByLine" o = BlameGetHunkByLineMethodInfo
ResolveBlameMethod "getHunkCount" o = BlameGetHunkCountMethodInfo
ResolveBlameMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveBlameMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveBlameMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveBlameMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveBlameMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveBlameMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBlameMethod t Blame, O.MethodInfo info Blame p) => OL.IsLabel t (Blame -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Blame
type instance O.AttributeList Blame = BlameAttributeList
type BlameAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
#endif
#if ENABLE_OVERLOADING
type instance O.SignalList Blame = BlameSignalList
type BlameSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_blame_from_buffer" ggit_blame_from_buffer ::
Ptr Blame ->
Ptr Word8 ->
Word64 ->
Ptr (Ptr GError) ->
IO (Ptr Blame)
blameFromBuffer ::
(B.CallStack.HasCallStack, MonadIO m, IsBlame a) =>
a
-> ByteString
-> m (Maybe Blame)
blameFromBuffer blame buffer = liftIO $ do
let bufferLength = fromIntegral $ B.length buffer
blame' <- unsafeManagedPtrCastPtr blame
buffer' <- packByteString buffer
onException (do
result <- propagateGError $ ggit_blame_from_buffer blame' buffer' bufferLength
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Blame) result'
return result''
touchManagedPtr blame
freeMem buffer'
return maybeResult
) (do
freeMem buffer'
)
#if ENABLE_OVERLOADING
data BlameFromBufferMethodInfo
instance (signature ~ (ByteString -> m (Maybe Blame)), MonadIO m, IsBlame a) => O.MethodInfo BlameFromBufferMethodInfo a signature where
overloadedMethod _ = blameFromBuffer
#endif
foreign import ccall "ggit_blame_get_hunk_by_index" ggit_blame_get_hunk_by_index ::
Ptr Blame ->
Word32 ->
IO (Ptr Ggit.BlameHunk.BlameHunk)
blameGetHunkByIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsBlame a) =>
a
-> Word32
-> m Ggit.BlameHunk.BlameHunk
blameGetHunkByIndex blame idx = liftIO $ do
blame' <- unsafeManagedPtrCastPtr blame
result <- ggit_blame_get_hunk_by_index blame' idx
checkUnexpectedReturnNULL "blameGetHunkByIndex" result
result' <- (wrapBoxed Ggit.BlameHunk.BlameHunk) result
touchManagedPtr blame
return result'
#if ENABLE_OVERLOADING
data BlameGetHunkByIndexMethodInfo
instance (signature ~ (Word32 -> m Ggit.BlameHunk.BlameHunk), MonadIO m, IsBlame a) => O.MethodInfo BlameGetHunkByIndexMethodInfo a signature where
overloadedMethod _ = blameGetHunkByIndex
#endif
foreign import ccall "ggit_blame_get_hunk_by_line" ggit_blame_get_hunk_by_line ::
Ptr Blame ->
Word32 ->
IO (Ptr Ggit.BlameHunk.BlameHunk)
blameGetHunkByLine ::
(B.CallStack.HasCallStack, MonadIO m, IsBlame a) =>
a
-> Word32
-> m Ggit.BlameHunk.BlameHunk
blameGetHunkByLine blame line = liftIO $ do
blame' <- unsafeManagedPtrCastPtr blame
result <- ggit_blame_get_hunk_by_line blame' line
checkUnexpectedReturnNULL "blameGetHunkByLine" result
result' <- (wrapBoxed Ggit.BlameHunk.BlameHunk) result
touchManagedPtr blame
return result'
#if ENABLE_OVERLOADING
data BlameGetHunkByLineMethodInfo
instance (signature ~ (Word32 -> m Ggit.BlameHunk.BlameHunk), MonadIO m, IsBlame a) => O.MethodInfo BlameGetHunkByLineMethodInfo a signature where
overloadedMethod _ = blameGetHunkByLine
#endif
foreign import ccall "ggit_blame_get_hunk_count" ggit_blame_get_hunk_count ::
Ptr Blame ->
IO Word32
blameGetHunkCount ::
(B.CallStack.HasCallStack, MonadIO m, IsBlame a) =>
a
-> m Word32
blameGetHunkCount blame = liftIO $ do
blame' <- unsafeManagedPtrCastPtr blame
result <- ggit_blame_get_hunk_count blame'
touchManagedPtr blame
return result
#if ENABLE_OVERLOADING
data BlameGetHunkCountMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsBlame a) => O.MethodInfo BlameGetHunkCountMethodInfo a signature where
overloadedMethod _ = blameGetHunkCount
#endif
foreign import ccall "ggit_blame_get_flags" ggit_blame_get_flags ::
Ptr Ggit.BlameOptions.BlameOptions ->
IO CUInt
blameGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ggit.BlameOptions.BlameOptions
-> m [Ggit.Flags.BlameFlags]
blameGetFlags blameOptions = liftIO $ do
blameOptions' <- unsafeManagedPtrGetPtr blameOptions
result <- ggit_blame_get_flags blameOptions'
let result' = wordToGFlags result
touchManagedPtr blameOptions
return result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "ggit_blame_set_flags" ggit_blame_set_flags ::
Ptr Ggit.BlameOptions.BlameOptions ->
CUInt ->
IO ()
blameSetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ggit.BlameOptions.BlameOptions
-> [Ggit.Flags.BlameFlags]
-> m ()
blameSetFlags blameOptions flags = liftIO $ do
blameOptions' <- unsafeManagedPtrGetPtr blameOptions
let flags' = gflagsToWord flags
ggit_blame_set_flags blameOptions' flags'
touchManagedPtr blameOptions
return ()
#if ENABLE_OVERLOADING
#endif