diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,11 @@ +### 1.0.4 + ++ Update to haskell-gi(-base) 0.22 + +### 1.0.3 + ++ Update stack version to 12.10 + ### 1.0.2 + Remove enable-overloading flags, and use instead explicit CPP checks for 'haskell-gi-overloading-1.0', see [how to disable overloading](https://github.com/haskell-gi/haskell-gi/wiki/Overloading\#disabling-overloading). diff --git a/GI/Ggit.hs b/GI/Ggit.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit.hs @@ -0,0 +1,56 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit + ( module GI.Ggit.Callbacks , + module GI.Ggit.Enums , + module GI.Ggit.Flags , + module GI.Ggit.Functions , + module GI.Ggit.Objects , + module GI.Ggit.Structs , + + + + module Data.GI.Base , + + + ) where + +import GI.Ggit.Callbacks +import GI.Ggit.Enums +import GI.Ggit.Flags +import GI.Ggit.Functions +import GI.Ggit.Objects +import GI.Ggit.Structs + +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 Data.GI.Base + diff --git a/GI/Ggit/Callbacks.hs b/GI/Ggit/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Callbacks.hs @@ -0,0 +1,2413 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Callbacks + ( + + -- * Signals +-- ** ConfigCallback #signal:ConfigCallback# + + C_ConfigCallback , + ConfigCallback , + ConfigCallback_WithClosures , + drop_closures_ConfigCallback , + dynamic_ConfigCallback , + genClosure_ConfigCallback , + mk_ConfigCallback , + noConfigCallback , + noConfigCallback_WithClosures , + wrap_ConfigCallback , + + +-- ** ConfigMatchCallback #signal:ConfigMatchCallback# + + C_ConfigMatchCallback , + ConfigMatchCallback , + ConfigMatchCallback_WithClosures , + drop_closures_ConfigMatchCallback , + dynamic_ConfigMatchCallback , + genClosure_ConfigMatchCallback , + mk_ConfigMatchCallback , + noConfigMatchCallback , + noConfigMatchCallback_WithClosures , + wrap_ConfigMatchCallback , + + +-- ** CredAcquireCallback #signal:CredAcquireCallback# + + C_CredAcquireCallback , + CredAcquireCallback , + CredAcquireCallback_WithClosures , + drop_closures_CredAcquireCallback , + dynamic_CredAcquireCallback , + genClosure_CredAcquireCallback , + mk_CredAcquireCallback , + noCredAcquireCallback , + noCredAcquireCallback_WithClosures , + wrap_CredAcquireCallback , + + +-- ** DiffBinaryCallback #signal:DiffBinaryCallback# + + C_DiffBinaryCallback , + DiffBinaryCallback , + DiffBinaryCallback_WithClosures , + drop_closures_DiffBinaryCallback , + dynamic_DiffBinaryCallback , + genClosure_DiffBinaryCallback , + mk_DiffBinaryCallback , + noDiffBinaryCallback , + noDiffBinaryCallback_WithClosures , + wrap_DiffBinaryCallback , + + +-- ** DiffFileCallback #signal:DiffFileCallback# + + C_DiffFileCallback , + DiffFileCallback , + DiffFileCallback_WithClosures , + drop_closures_DiffFileCallback , + dynamic_DiffFileCallback , + genClosure_DiffFileCallback , + mk_DiffFileCallback , + noDiffFileCallback , + noDiffFileCallback_WithClosures , + wrap_DiffFileCallback , + + +-- ** DiffHunkCallback #signal:DiffHunkCallback# + + C_DiffHunkCallback , + DiffHunkCallback , + DiffHunkCallback_WithClosures , + drop_closures_DiffHunkCallback , + dynamic_DiffHunkCallback , + genClosure_DiffHunkCallback , + mk_DiffHunkCallback , + noDiffHunkCallback , + noDiffHunkCallback_WithClosures , + wrap_DiffHunkCallback , + + +-- ** DiffLineCallback #signal:DiffLineCallback# + + C_DiffLineCallback , + DiffLineCallback , + DiffLineCallback_WithClosures , + drop_closures_DiffLineCallback , + dynamic_DiffLineCallback , + genClosure_DiffLineCallback , + mk_DiffLineCallback , + noDiffLineCallback , + noDiffLineCallback_WithClosures , + wrap_DiffLineCallback , + + +-- ** DiffSimilarityMetricBufferSignatureCallback #signal:DiffSimilarityMetricBufferSignatureCallback# + + C_DiffSimilarityMetricBufferSignatureCallback, + DiffSimilarityMetricBufferSignatureCallback, + DiffSimilarityMetricBufferSignatureCallback_WithClosures, + drop_closures_DiffSimilarityMetricBufferSignatureCallback, + dynamic_DiffSimilarityMetricBufferSignatureCallback, + genClosure_DiffSimilarityMetricBufferSignatureCallback, + mk_DiffSimilarityMetricBufferSignatureCallback, + noDiffSimilarityMetricBufferSignatureCallback, + noDiffSimilarityMetricBufferSignatureCallback_WithClosures, + wrap_DiffSimilarityMetricBufferSignatureCallback, + + +-- ** DiffSimilarityMetricFileSignatureCallback #signal:DiffSimilarityMetricFileSignatureCallback# + + C_DiffSimilarityMetricFileSignatureCallback, + DiffSimilarityMetricFileSignatureCallback, + DiffSimilarityMetricFileSignatureCallback_WithClosures, + drop_closures_DiffSimilarityMetricFileSignatureCallback, + dynamic_DiffSimilarityMetricFileSignatureCallback, + genClosure_DiffSimilarityMetricFileSignatureCallback, + mk_DiffSimilarityMetricFileSignatureCallback, + noDiffSimilarityMetricFileSignatureCallback, + noDiffSimilarityMetricFileSignatureCallback_WithClosures, + wrap_DiffSimilarityMetricFileSignatureCallback, + + +-- ** DiffSimilarityMetricFreeSignatureCallback #signal:DiffSimilarityMetricFreeSignatureCallback# + + C_DiffSimilarityMetricFreeSignatureCallback, + DiffSimilarityMetricFreeSignatureCallback, + DiffSimilarityMetricFreeSignatureCallback_WithClosures, + drop_closures_DiffSimilarityMetricFreeSignatureCallback, + dynamic_DiffSimilarityMetricFreeSignatureCallback, + genClosure_DiffSimilarityMetricFreeSignatureCallback, + mk_DiffSimilarityMetricFreeSignatureCallback, + noDiffSimilarityMetricFreeSignatureCallback, + noDiffSimilarityMetricFreeSignatureCallback_WithClosures, + wrap_DiffSimilarityMetricFreeSignatureCallback, + + +-- ** DiffSimilarityMetricSimilarityCallback #signal:DiffSimilarityMetricSimilarityCallback# + + C_DiffSimilarityMetricSimilarityCallback, + DiffSimilarityMetricSimilarityCallback , + DiffSimilarityMetricSimilarityCallback_WithClosures, + drop_closures_DiffSimilarityMetricSimilarityCallback, + dynamic_DiffSimilarityMetricSimilarityCallback, + genClosure_DiffSimilarityMetricSimilarityCallback, + mk_DiffSimilarityMetricSimilarityCallback, + noDiffSimilarityMetricSimilarityCallback, + noDiffSimilarityMetricSimilarityCallback_WithClosures, + wrap_DiffSimilarityMetricSimilarityCallback, + + +-- ** NoteCallback #signal:NoteCallback# + + C_NoteCallback , + NoteCallback , + NoteCallback_WithClosures , + drop_closures_NoteCallback , + dynamic_NoteCallback , + genClosure_NoteCallback , + mk_NoteCallback , + noNoteCallback , + noNoteCallback_WithClosures , + wrap_NoteCallback , + + +-- ** ReferencesCallback #signal:ReferencesCallback# + + C_ReferencesCallback , + ReferencesCallback , + ReferencesCallback_WithClosures , + drop_closures_ReferencesCallback , + dynamic_ReferencesCallback , + genClosure_ReferencesCallback , + mk_ReferencesCallback , + noReferencesCallback , + noReferencesCallback_WithClosures , + wrap_ReferencesCallback , + + +-- ** ReferencesNameCallback #signal:ReferencesNameCallback# + + C_ReferencesNameCallback , + ReferencesNameCallback , + ReferencesNameCallback_WithClosures , + drop_closures_ReferencesNameCallback , + dynamic_ReferencesNameCallback , + genClosure_ReferencesNameCallback , + mk_ReferencesNameCallback , + noReferencesNameCallback , + noReferencesNameCallback_WithClosures , + wrap_ReferencesNameCallback , + + +-- ** RemoteListCallback #signal:RemoteListCallback# + + C_RemoteListCallback , + RemoteListCallback , + RemoteListCallback_WithClosures , + drop_closures_RemoteListCallback , + dynamic_RemoteListCallback , + genClosure_RemoteListCallback , + mk_RemoteListCallback , + noRemoteListCallback , + noRemoteListCallback_WithClosures , + wrap_RemoteListCallback , + + +-- ** StashCallback #signal:StashCallback# + + C_StashCallback , + StashCallback , + StashCallback_WithClosures , + drop_closures_StashCallback , + dynamic_StashCallback , + genClosure_StashCallback , + mk_StashCallback , + noStashCallback , + noStashCallback_WithClosures , + wrap_StashCallback , + + +-- ** StatusCallback #signal:StatusCallback# + + C_StatusCallback , + StatusCallback , + StatusCallback_WithClosures , + drop_closures_StatusCallback , + dynamic_StatusCallback , + genClosure_StatusCallback , + mk_StatusCallback , + noStatusCallback , + noStatusCallback_WithClosures , + wrap_StatusCallback , + + +-- ** SubmoduleCallback #signal:SubmoduleCallback# + + C_SubmoduleCallback , + SubmoduleCallback , + SubmoduleCallback_WithClosures , + drop_closures_SubmoduleCallback , + dynamic_SubmoduleCallback , + genClosure_SubmoduleCallback , + mk_SubmoduleCallback , + noSubmoduleCallback , + noSubmoduleCallback_WithClosures , + wrap_SubmoduleCallback , + + +-- ** TagCallback #signal:TagCallback# + + C_TagCallback , + TagCallback , + TagCallback_WithClosures , + drop_closures_TagCallback , + dynamic_TagCallback , + genClosure_TagCallback , + mk_TagCallback , + noTagCallback , + noTagCallback_WithClosures , + wrap_TagCallback , + + +-- ** TransferProgressCallback #signal:TransferProgressCallback# + + C_TransferProgressCallback , + TransferProgressCallback , + TransferProgressCallback_WithClosures , + drop_closures_TransferProgressCallback , + dynamic_TransferProgressCallback , + genClosure_TransferProgressCallback , + mk_TransferProgressCallback , + noTransferProgressCallback , + noTransferProgressCallback_WithClosures , + wrap_TransferProgressCallback , + + +-- ** TreeWalkCallback #signal:TreeWalkCallback# + + C_TreeWalkCallback , + TreeWalkCallback , + TreeWalkCallback_WithClosures , + drop_closures_TreeWalkCallback , + dynamic_TreeWalkCallback , + genClosure_TreeWalkCallback , + mk_TreeWalkCallback , + noTreeWalkCallback , + noTreeWalkCallback_WithClosures , + wrap_TreeWalkCallback , + + + + + ) 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.GLib.Structs.MatchInfo as GLib.MatchInfo +import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags +import {-# SOURCE #-} qualified GI.Ggit.Objects.Cred as Ggit.Cred +import {-# SOURCE #-} qualified GI.Ggit.Objects.Ref as Ggit.Ref +import {-# SOURCE #-} qualified GI.Ggit.Structs.ConfigEntry as Ggit.ConfigEntry +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffBinary as Ggit.DiffBinary +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffDelta as Ggit.DiffDelta +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffFile as Ggit.DiffFile +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffHunk as Ggit.DiffHunk +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffLine as Ggit.DiffLine +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.Submodule as Ggit.Submodule +import {-# SOURCE #-} qualified GI.Ggit.Structs.TransferProgress as Ggit.TransferProgress +import {-# SOURCE #-} qualified GI.Ggit.Structs.TreeEntry as Ggit.TreeEntry + +-- callback TreeWalkCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go for the next entry or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "root", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the current (relative) root of the entry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tree entry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for walking a tree.\nSee ggit_tree_walk().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_TreeWalkCallback = + CString -> + Ptr Ggit.TreeEntry.TreeEntry -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "root", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the current (relative) root of the entry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tree entry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_TreeWalkCallback :: FunPtr C_TreeWalkCallback -> C_TreeWalkCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_TreeWalkCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_TreeWalkCallback + -> T.Text + {- ^ /@root@/: the current (relative) root of the entry -} + -> Ggit.TreeEntry.TreeEntry + {- ^ /@entry@/: the tree entry -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go for the next entry or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_TreeWalkCallback __funPtr root entry userData = liftIO $ do + root' <- textToCString root + entry' <- unsafeManagedPtrGetPtr entry + result <- (__dynamic_C_TreeWalkCallback __funPtr) root' entry' userData + touchManagedPtr entry + freeMem root' + return result + +-- | Generate a function pointer callable from C code, from a `C_TreeWalkCallback`. +foreign import ccall "wrapper" + mk_TreeWalkCallback :: C_TreeWalkCallback -> IO (FunPtr C_TreeWalkCallback) + +{- | +The type of the callback functions for walking a tree. +See 'GI.Ggit.Objects.Tree.treeWalk'. +-} +type TreeWalkCallback = + T.Text + {- ^ /@root@/: the current (relative) root of the entry -} + -> Ggit.TreeEntry.TreeEntry + {- ^ /@entry@/: the tree entry -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next entry or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `TreeWalkCallback`@. +noTreeWalkCallback :: Maybe TreeWalkCallback +noTreeWalkCallback = Nothing + +{- | +The type of the callback functions for walking a tree. +See 'GI.Ggit.Objects.Tree.treeWalk'. +-} +type TreeWalkCallback_WithClosures = + T.Text + {- ^ /@root@/: the current (relative) root of the entry -} + -> Ggit.TreeEntry.TreeEntry + {- ^ /@entry@/: the tree entry -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next entry or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `TreeWalkCallback_WithClosures`@. +noTreeWalkCallback_WithClosures :: Maybe TreeWalkCallback_WithClosures +noTreeWalkCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_TreeWalkCallback :: TreeWalkCallback -> TreeWalkCallback_WithClosures +drop_closures_TreeWalkCallback _f root entry _ = _f root entry + +-- | Wrap the callback into a `GClosure`. +genClosure_TreeWalkCallback :: MonadIO m => TreeWalkCallback -> m (GClosure C_TreeWalkCallback) +genClosure_TreeWalkCallback cb = liftIO $ do + let cb' = drop_closures_TreeWalkCallback cb + let cb'' = wrap_TreeWalkCallback Nothing cb' + mk_TreeWalkCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `TreeWalkCallback` into a `C_TreeWalkCallback`. +wrap_TreeWalkCallback :: + Maybe (Ptr (FunPtr C_TreeWalkCallback)) -> + TreeWalkCallback_WithClosures -> + C_TreeWalkCallback +wrap_TreeWalkCallback funptrptr _cb root entry userData = do + root' <- cstringToText root + B.ManagedPtr.withTransient Ggit.TreeEntry.TreeEntry entry $ \entry' -> do + result <- _cb root' entry' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback TransferProgressCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "a value less than zero to cancel the transfer.", sinceVersion = Nothing}, args = [Arg {argCName = "stats", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Progress callbacks during indexing.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_TransferProgressCallback = + Ptr Ggit.TransferProgress.TransferProgress -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "stats", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_TransferProgressCallback :: FunPtr C_TransferProgressCallback -> C_TransferProgressCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_TransferProgressCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_TransferProgressCallback + -> Ggit.TransferProgress.TransferProgress + {- ^ /@stats@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ a value less than zero to cancel the transfer. -} +dynamic_TransferProgressCallback __funPtr stats userData = liftIO $ do + stats' <- unsafeManagedPtrGetPtr stats + result <- (__dynamic_C_TransferProgressCallback __funPtr) stats' userData + touchManagedPtr stats + return result + +-- | Generate a function pointer callable from C code, from a `C_TransferProgressCallback`. +foreign import ccall "wrapper" + mk_TransferProgressCallback :: C_TransferProgressCallback -> IO (FunPtr C_TransferProgressCallback) + +{- | +Progress callbacks during indexing. +-} +type TransferProgressCallback = + Ggit.TransferProgress.TransferProgress + {- ^ /@stats@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> IO Int32 + {- ^ __Returns:__ a value less than zero to cancel the transfer. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `TransferProgressCallback`@. +noTransferProgressCallback :: Maybe TransferProgressCallback +noTransferProgressCallback = Nothing + +{- | +Progress callbacks during indexing. +-} +type TransferProgressCallback_WithClosures = + Ggit.TransferProgress.TransferProgress + {- ^ /@stats@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ a value less than zero to cancel the transfer. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `TransferProgressCallback_WithClosures`@. +noTransferProgressCallback_WithClosures :: Maybe TransferProgressCallback_WithClosures +noTransferProgressCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_TransferProgressCallback :: TransferProgressCallback -> TransferProgressCallback_WithClosures +drop_closures_TransferProgressCallback _f stats _ = _f stats + +-- | Wrap the callback into a `GClosure`. +genClosure_TransferProgressCallback :: MonadIO m => TransferProgressCallback -> m (GClosure C_TransferProgressCallback) +genClosure_TransferProgressCallback cb = liftIO $ do + let cb' = drop_closures_TransferProgressCallback cb + let cb'' = wrap_TransferProgressCallback Nothing cb' + mk_TransferProgressCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `TransferProgressCallback` into a `C_TransferProgressCallback`. +wrap_TransferProgressCallback :: + Maybe (Ptr (FunPtr C_TransferProgressCallback)) -> + TransferProgressCallback_WithClosures -> + C_TransferProgressCallback +wrap_TransferProgressCallback funptrptr _cb stats userData = do + B.ManagedPtr.withTransient Ggit.TransferProgress.TransferProgress stats $ \stats' -> do + result <- _cb stats' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback TagCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag oid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-suplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "When iterating over all the tags, callback that will be\nissued per entry. See ggit_repository_tag_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_TagCallback = + CString -> + Ptr Ggit.OId.OId -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag oid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-suplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_TagCallback :: FunPtr C_TagCallback -> C_TagCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_TagCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_TagCallback + -> T.Text + {- ^ /@name@/: the tag name. -} + -> Ggit.OId.OId + {- ^ /@tagOid@/: the tag oid. -} + -> Ptr () + {- ^ /@userData@/: user-suplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_TagCallback __funPtr name tagOid userData = liftIO $ do + name' <- textToCString name + tagOid' <- unsafeManagedPtrGetPtr tagOid + result <- (__dynamic_C_TagCallback __funPtr) name' tagOid' userData + touchManagedPtr tagOid + freeMem name' + return result + +-- | Generate a function pointer callable from C code, from a `C_TagCallback`. +foreign import ccall "wrapper" + mk_TagCallback :: C_TagCallback -> IO (FunPtr C_TagCallback) + +{- | +When iterating over all the tags, callback that will be +issued per entry. See 'GI.Ggit.Objects.Repository.repositoryTagForeach'. +-} +type TagCallback = + T.Text + {- ^ /@name@/: the tag name. -} + -> Ggit.OId.OId + {- ^ /@tagOid@/: the tag oid. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `TagCallback`@. +noTagCallback :: Maybe TagCallback +noTagCallback = Nothing + +{- | +When iterating over all the tags, callback that will be +issued per entry. See 'GI.Ggit.Objects.Repository.repositoryTagForeach'. +-} +type TagCallback_WithClosures = + T.Text + {- ^ /@name@/: the tag name. -} + -> Ggit.OId.OId + {- ^ /@tagOid@/: the tag oid. -} + -> Ptr () + {- ^ /@userData@/: user-suplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `TagCallback_WithClosures`@. +noTagCallback_WithClosures :: Maybe TagCallback_WithClosures +noTagCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_TagCallback :: TagCallback -> TagCallback_WithClosures +drop_closures_TagCallback _f name tagOid _ = _f name tagOid + +-- | Wrap the callback into a `GClosure`. +genClosure_TagCallback :: MonadIO m => TagCallback -> m (GClosure C_TagCallback) +genClosure_TagCallback cb = liftIO $ do + let cb' = drop_closures_TagCallback cb + let cb'' = wrap_TagCallback Nothing cb' + mk_TagCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `TagCallback` into a `C_TagCallback`. +wrap_TagCallback :: + Maybe (Ptr (FunPtr C_TagCallback)) -> + TagCallback_WithClosures -> + C_TagCallback +wrap_TagCallback funptrptr _cb name tagOid userData = do + name' <- cstringToText name + B.ManagedPtr.withTransient Ggit.OId.OId tagOid $ \tagOid' -> do + result <- _cb name' tagOid' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback SubmoduleCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go for the next submodule or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for retrieving the submodules\nin a #GgitRepository. See ggit_repository_submodule_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_SubmoduleCallback = + Ptr Ggit.Submodule.Submodule -> + CString -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_SubmoduleCallback :: FunPtr C_SubmoduleCallback -> C_SubmoduleCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_SubmoduleCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_SubmoduleCallback + -> Ggit.Submodule.Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go for the next submodule or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_SubmoduleCallback __funPtr submodule name userData = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + name' <- textToCString name + result <- (__dynamic_C_SubmoduleCallback __funPtr) submodule' name' userData + touchManagedPtr submodule + freeMem name' + return result + +-- | Generate a function pointer callable from C code, from a `C_SubmoduleCallback`. +foreign import ccall "wrapper" + mk_SubmoduleCallback :: C_SubmoduleCallback -> IO (FunPtr C_SubmoduleCallback) + +{- | +The type of the callback functions for retrieving the submodules +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositorySubmoduleForeach'. +-} +type SubmoduleCallback = + Ggit.Submodule.Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next submodule or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `SubmoduleCallback`@. +noSubmoduleCallback :: Maybe SubmoduleCallback +noSubmoduleCallback = Nothing + +{- | +The type of the callback functions for retrieving the submodules +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositorySubmoduleForeach'. +-} +type SubmoduleCallback_WithClosures = + Ggit.Submodule.Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next submodule or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `SubmoduleCallback_WithClosures`@. +noSubmoduleCallback_WithClosures :: Maybe SubmoduleCallback_WithClosures +noSubmoduleCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_SubmoduleCallback :: SubmoduleCallback -> SubmoduleCallback_WithClosures +drop_closures_SubmoduleCallback _f submodule name _ = _f submodule name + +-- | Wrap the callback into a `GClosure`. +genClosure_SubmoduleCallback :: MonadIO m => SubmoduleCallback -> m (GClosure C_SubmoduleCallback) +genClosure_SubmoduleCallback cb = liftIO $ do + let cb' = drop_closures_SubmoduleCallback cb + let cb'' = wrap_SubmoduleCallback Nothing cb' + mk_SubmoduleCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `SubmoduleCallback` into a `C_SubmoduleCallback`. +wrap_SubmoduleCallback :: + Maybe (Ptr (FunPtr C_SubmoduleCallback)) -> + SubmoduleCallback_WithClosures -> + C_SubmoduleCallback +wrap_SubmoduleCallback funptrptr _cb submodule name userData = do + B.ManagedPtr.withTransient Ggit.Submodule.Submodule submodule $ \submodule' -> do + name' <- cstringToText name + result <- _cb submodule' name' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback StatusCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go for the next file or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file to retrieve status for, rooted at the repository working dir.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "status_flags", argType = TInterface (Name {namespace = "Ggit", name = "StatusFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the status value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for retrieving the status of the files\nin a #GgitRepository. See ggit_repository_file_status_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_StatusCallback = + CString -> + CUInt -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file to retrieve status for, rooted at the repository working dir.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "status_flags", argType = TInterface (Name {namespace = "Ggit", name = "StatusFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the status value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_StatusCallback :: FunPtr C_StatusCallback -> C_StatusCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_StatusCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_StatusCallback + -> T.Text + {- ^ /@path@/: the file to retrieve status for, rooted at the repository working dir. -} + -> [Ggit.Flags.StatusFlags] + {- ^ /@statusFlags@/: the status value. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go for the next file or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_StatusCallback __funPtr path statusFlags userData = liftIO $ do + path' <- textToCString path + let statusFlags' = gflagsToWord statusFlags + result <- (__dynamic_C_StatusCallback __funPtr) path' statusFlags' userData + freeMem path' + return result + +-- | Generate a function pointer callable from C code, from a `C_StatusCallback`. +foreign import ccall "wrapper" + mk_StatusCallback :: C_StatusCallback -> IO (FunPtr C_StatusCallback) + +{- | +The type of the callback functions for retrieving the status of the files +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositoryFileStatusForeach'. +-} +type StatusCallback = + T.Text + {- ^ /@path@/: the file to retrieve status for, rooted at the repository working dir. -} + -> [Ggit.Flags.StatusFlags] + {- ^ /@statusFlags@/: the status value. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next file or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `StatusCallback`@. +noStatusCallback :: Maybe StatusCallback +noStatusCallback = Nothing + +{- | +The type of the callback functions for retrieving the status of the files +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositoryFileStatusForeach'. +-} +type StatusCallback_WithClosures = + T.Text + {- ^ /@path@/: the file to retrieve status for, rooted at the repository working dir. -} + -> [Ggit.Flags.StatusFlags] + {- ^ /@statusFlags@/: the status value. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next file or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `StatusCallback_WithClosures`@. +noStatusCallback_WithClosures :: Maybe StatusCallback_WithClosures +noStatusCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_StatusCallback :: StatusCallback -> StatusCallback_WithClosures +drop_closures_StatusCallback _f path statusFlags _ = _f path statusFlags + +-- | Wrap the callback into a `GClosure`. +genClosure_StatusCallback :: MonadIO m => StatusCallback -> m (GClosure C_StatusCallback) +genClosure_StatusCallback cb = liftIO $ do + let cb' = drop_closures_StatusCallback cb + let cb'' = wrap_StatusCallback Nothing cb' + mk_StatusCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `StatusCallback` into a `C_StatusCallback`. +wrap_StatusCallback :: + Maybe (Ptr (FunPtr C_StatusCallback)) -> + StatusCallback_WithClosures -> + C_StatusCallback +wrap_StatusCallback funptrptr _cb path statusFlags userData = do + path' <- cstringToText path + let statusFlags' = wordToGFlags statusFlags + result <- _cb path' statusFlags' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback StashCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "index", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position within the stash list. 0 points to the\nmost recent stashed state.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stash message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stash_oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the commit oid of the stashed state.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-suplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "When iterating over all the stashed states, callback that will be\nissued per entry. See ggit_repository_stash_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_StashCallback = + Word64 -> + CString -> + Ptr Ggit.OId.OId -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "index", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position within the stash list. 0 points to the\nmost recent stashed state.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stash message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stash_oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the commit oid of the stashed state.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-suplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_StashCallback :: FunPtr C_StashCallback -> C_StashCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_StashCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_StashCallback + -> Word64 + {- ^ /@index@/: the position within the stash list. 0 points to the +most recent stashed state. -} + -> T.Text + {- ^ /@message@/: the stash message. -} + -> Ggit.OId.OId + {- ^ /@stashOid@/: the commit oid of the stashed state. -} + -> Ptr () + {- ^ /@userData@/: user-suplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_StashCallback __funPtr index message stashOid userData = liftIO $ do + message' <- textToCString message + stashOid' <- unsafeManagedPtrGetPtr stashOid + result <- (__dynamic_C_StashCallback __funPtr) index message' stashOid' userData + touchManagedPtr stashOid + freeMem message' + return result + +-- | Generate a function pointer callable from C code, from a `C_StashCallback`. +foreign import ccall "wrapper" + mk_StashCallback :: C_StashCallback -> IO (FunPtr C_StashCallback) + +{- | +When iterating over all the stashed states, callback that will be +issued per entry. See 'GI.Ggit.Objects.Repository.repositoryStashForeach'. +-} +type StashCallback = + Word64 + {- ^ /@index@/: the position within the stash list. 0 points to the +most recent stashed state. -} + -> T.Text + {- ^ /@message@/: the stash message. -} + -> Ggit.OId.OId + {- ^ /@stashOid@/: the commit oid of the stashed state. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `StashCallback`@. +noStashCallback :: Maybe StashCallback +noStashCallback = Nothing + +{- | +When iterating over all the stashed states, callback that will be +issued per entry. See 'GI.Ggit.Objects.Repository.repositoryStashForeach'. +-} +type StashCallback_WithClosures = + Word64 + {- ^ /@index@/: the position within the stash list. 0 points to the +most recent stashed state. -} + -> T.Text + {- ^ /@message@/: the stash message. -} + -> Ggit.OId.OId + {- ^ /@stashOid@/: the commit oid of the stashed state. -} + -> Ptr () + {- ^ /@userData@/: user-suplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `StashCallback_WithClosures`@. +noStashCallback_WithClosures :: Maybe StashCallback_WithClosures +noStashCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_StashCallback :: StashCallback -> StashCallback_WithClosures +drop_closures_StashCallback _f index message stashOid _ = _f index message stashOid + +-- | Wrap the callback into a `GClosure`. +genClosure_StashCallback :: MonadIO m => StashCallback -> m (GClosure C_StashCallback) +genClosure_StashCallback cb = liftIO $ do + let cb' = drop_closures_StashCallback cb + let cb'' = wrap_StashCallback Nothing cb' + mk_StashCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `StashCallback` into a `C_StashCallback`. +wrap_StashCallback :: + Maybe (Ptr (FunPtr C_StashCallback)) -> + StashCallback_WithClosures -> + C_StashCallback +wrap_StashCallback funptrptr _cb index message stashOid userData = do + message' <- cstringToText message + B.ManagedPtr.withTransient Ggit.OId.OId stashOid $ \stashOid' -> do + result <- _cb index message' stashOid' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback RemoteListCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference's oid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "loid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference's loid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "local", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if available locally.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for listing the references of a\n#GgitRemote. See ggit_remote_list().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_RemoteListCallback = + CString -> + Ptr Ggit.OId.OId -> + Ptr Ggit.OId.OId -> + CInt -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference's oid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "loid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference's loid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "local", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if available locally.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_RemoteListCallback :: FunPtr C_RemoteListCallback -> C_RemoteListCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_RemoteListCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_RemoteListCallback + -> T.Text + {- ^ /@name@/: the name of the reference. -} + -> Ggit.OId.OId + {- ^ /@oid@/: the reference\'s oid. -} + -> Ggit.OId.OId + {- ^ /@loid@/: the reference\'s loid. -} + -> Bool + {- ^ /@local@/: if available locally. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_RemoteListCallback __funPtr name oid loid local userData = liftIO $ do + name' <- textToCString name + oid' <- unsafeManagedPtrGetPtr oid + loid' <- unsafeManagedPtrGetPtr loid + let local' = (fromIntegral . fromEnum) local + result <- (__dynamic_C_RemoteListCallback __funPtr) name' oid' loid' local' userData + touchManagedPtr oid + touchManagedPtr loid + freeMem name' + return result + +-- | Generate a function pointer callable from C code, from a `C_RemoteListCallback`. +foreign import ccall "wrapper" + mk_RemoteListCallback :: C_RemoteListCallback -> IO (FunPtr C_RemoteListCallback) + +{- | +The type of the callback functions for listing the references of a +'GI.Ggit.Objects.Remote.Remote'. See 'GI.Ggit.Objects.Remote.remoteList'. +-} +type RemoteListCallback = + T.Text + {- ^ /@name@/: the name of the reference. -} + -> Ggit.OId.OId + {- ^ /@oid@/: the reference\'s oid. -} + -> Ggit.OId.OId + {- ^ /@loid@/: the reference\'s loid. -} + -> Bool + {- ^ /@local@/: if available locally. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteListCallback`@. +noRemoteListCallback :: Maybe RemoteListCallback +noRemoteListCallback = Nothing + +{- | +The type of the callback functions for listing the references of a +'GI.Ggit.Objects.Remote.Remote'. See 'GI.Ggit.Objects.Remote.remoteList'. +-} +type RemoteListCallback_WithClosures = + T.Text + {- ^ /@name@/: the name of the reference. -} + -> Ggit.OId.OId + {- ^ /@oid@/: the reference\'s oid. -} + -> Ggit.OId.OId + {- ^ /@loid@/: the reference\'s loid. -} + -> Bool + {- ^ /@local@/: if available locally. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteListCallback_WithClosures`@. +noRemoteListCallback_WithClosures :: Maybe RemoteListCallback_WithClosures +noRemoteListCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_RemoteListCallback :: RemoteListCallback -> RemoteListCallback_WithClosures +drop_closures_RemoteListCallback _f name oid loid local _ = _f name oid loid local + +-- | Wrap the callback into a `GClosure`. +genClosure_RemoteListCallback :: MonadIO m => RemoteListCallback -> m (GClosure C_RemoteListCallback) +genClosure_RemoteListCallback cb = liftIO $ do + let cb' = drop_closures_RemoteListCallback cb + let cb'' = wrap_RemoteListCallback Nothing cb' + mk_RemoteListCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `RemoteListCallback` into a `C_RemoteListCallback`. +wrap_RemoteListCallback :: + Maybe (Ptr (FunPtr C_RemoteListCallback)) -> + RemoteListCallback_WithClosures -> + C_RemoteListCallback +wrap_RemoteListCallback funptrptr _cb name oid loid local userData = do + name' <- cstringToText name + B.ManagedPtr.withTransient Ggit.OId.OId oid $ \oid' -> do + B.ManagedPtr.withTransient Ggit.OId.OId loid $ \loid' -> do + let local' = (/= 0) local + result <- _cb name' oid' loid' local' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback ReferencesNameCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go for the next references or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the reference", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for retrieving the references\nin a #GgitRepository. See ggit_repository_references_foreach_name().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ReferencesNameCallback = + CString -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the reference", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ReferencesNameCallback :: FunPtr C_ReferencesNameCallback -> C_ReferencesNameCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ReferencesNameCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_ReferencesNameCallback + -> T.Text + {- ^ /@name@/: the name of the reference -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go for the next references or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_ReferencesNameCallback __funPtr name userData = liftIO $ do + name' <- textToCString name + result <- (__dynamic_C_ReferencesNameCallback __funPtr) name' userData + freeMem name' + return result + +-- | Generate a function pointer callable from C code, from a `C_ReferencesNameCallback`. +foreign import ccall "wrapper" + mk_ReferencesNameCallback :: C_ReferencesNameCallback -> IO (FunPtr C_ReferencesNameCallback) + +{- | +The type of the callback functions for retrieving the references +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositoryReferencesForeachName'. +-} +type ReferencesNameCallback = + T.Text + {- ^ /@name@/: the name of the reference -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next references or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ReferencesNameCallback`@. +noReferencesNameCallback :: Maybe ReferencesNameCallback +noReferencesNameCallback = Nothing + +{- | +The type of the callback functions for retrieving the references +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositoryReferencesForeachName'. +-} +type ReferencesNameCallback_WithClosures = + T.Text + {- ^ /@name@/: the name of the reference -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next references or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ReferencesNameCallback_WithClosures`@. +noReferencesNameCallback_WithClosures :: Maybe ReferencesNameCallback_WithClosures +noReferencesNameCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_ReferencesNameCallback :: ReferencesNameCallback -> ReferencesNameCallback_WithClosures +drop_closures_ReferencesNameCallback _f name _ = _f name + +-- | Wrap the callback into a `GClosure`. +genClosure_ReferencesNameCallback :: MonadIO m => ReferencesNameCallback -> m (GClosure C_ReferencesNameCallback) +genClosure_ReferencesNameCallback cb = liftIO $ do + let cb' = drop_closures_ReferencesNameCallback cb + let cb'' = wrap_ReferencesNameCallback Nothing cb' + mk_ReferencesNameCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `ReferencesNameCallback` into a `C_ReferencesNameCallback`. +wrap_ReferencesNameCallback :: + Maybe (Ptr (FunPtr C_ReferencesNameCallback)) -> + ReferencesNameCallback_WithClosures -> + C_ReferencesNameCallback +wrap_ReferencesNameCallback funptrptr _cb name userData = do + name' <- cstringToText name + result <- _cb name' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback ReferencesCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go for the next references or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "reference", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for retrieving the references\nin a #GgitRepository. See ggit_repository_references_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ReferencesCallback = + Ptr Ggit.Ref.Ref -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "reference", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ReferencesCallback :: FunPtr C_ReferencesCallback -> C_ReferencesCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ReferencesCallback :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Ref.IsRef a) => + FunPtr C_ReferencesCallback + -> a + {- ^ /@reference@/: the reference. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go for the next references or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_ReferencesCallback __funPtr reference userData = liftIO $ do + reference' <- B.ManagedPtr.disownObject reference + result <- (__dynamic_C_ReferencesCallback __funPtr) reference' userData + touchManagedPtr reference + return result + +-- | Generate a function pointer callable from C code, from a `C_ReferencesCallback`. +foreign import ccall "wrapper" + mk_ReferencesCallback :: C_ReferencesCallback -> IO (FunPtr C_ReferencesCallback) + +{- | +The type of the callback functions for retrieving the references +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositoryReferencesForeach'. +-} +type ReferencesCallback = + Ggit.Ref.Ref + {- ^ /@reference@/: the reference. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next references or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ReferencesCallback`@. +noReferencesCallback :: Maybe ReferencesCallback +noReferencesCallback = Nothing + +{- | +The type of the callback functions for retrieving the references +in a 'GI.Ggit.Objects.Repository.Repository'. See 'GI.Ggit.Objects.Repository.repositoryReferencesForeach'. +-} +type ReferencesCallback_WithClosures = + Ggit.Ref.Ref + {- ^ /@reference@/: the reference. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next references or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ReferencesCallback_WithClosures`@. +noReferencesCallback_WithClosures :: Maybe ReferencesCallback_WithClosures +noReferencesCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_ReferencesCallback :: ReferencesCallback -> ReferencesCallback_WithClosures +drop_closures_ReferencesCallback _f reference _ = _f reference + +-- | Wrap the callback into a `GClosure`. +genClosure_ReferencesCallback :: MonadIO m => ReferencesCallback -> m (GClosure C_ReferencesCallback) +genClosure_ReferencesCallback cb = liftIO $ do + let cb' = drop_closures_ReferencesCallback cb + let cb'' = wrap_ReferencesCallback Nothing cb' + mk_ReferencesCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `ReferencesCallback` into a `C_ReferencesCallback`. +wrap_ReferencesCallback :: + Maybe (Ptr (FunPtr C_ReferencesCallback)) -> + ReferencesCallback_WithClosures -> + C_ReferencesCallback +wrap_ReferencesCallback funptrptr _cb reference userData = do + reference' <- (wrapObject Ggit.Ref.Ref) reference + result <- _cb reference' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback NoteCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "blob_id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "id of the blob containing the message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "annotated_object_id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "id of the git object being annotated.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-suplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "When iterating over all the notes, callback that will be\nissued per note. See ggit_repository_note_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_NoteCallback = + Ptr Ggit.OId.OId -> + Ptr Ggit.OId.OId -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "blob_id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "id of the blob containing the message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "annotated_object_id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "id of the git object being annotated.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-suplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_NoteCallback :: FunPtr C_NoteCallback -> C_NoteCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_NoteCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_NoteCallback + -> Ggit.OId.OId + {- ^ /@blobId@/: id of the blob containing the message. -} + -> Ggit.OId.OId + {- ^ /@annotatedObjectId@/: id of the git object being annotated. -} + -> Ptr () + {- ^ /@userData@/: user-suplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_NoteCallback __funPtr blobId annotatedObjectId userData = liftIO $ do + blobId' <- unsafeManagedPtrGetPtr blobId + annotatedObjectId' <- unsafeManagedPtrGetPtr annotatedObjectId + result <- (__dynamic_C_NoteCallback __funPtr) blobId' annotatedObjectId' userData + touchManagedPtr blobId + touchManagedPtr annotatedObjectId + return result + +-- | Generate a function pointer callable from C code, from a `C_NoteCallback`. +foreign import ccall "wrapper" + mk_NoteCallback :: C_NoteCallback -> IO (FunPtr C_NoteCallback) + +{- | +When iterating over all the notes, callback that will be +issued per note. See 'GI.Ggit.Objects.Repository.repositoryNoteForeach'. +-} +type NoteCallback = + Ggit.OId.OId + {- ^ /@blobId@/: id of the blob containing the message. -} + -> Ggit.OId.OId + {- ^ /@annotatedObjectId@/: id of the git object being annotated. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `NoteCallback`@. +noNoteCallback :: Maybe NoteCallback +noNoteCallback = Nothing + +{- | +When iterating over all the notes, callback that will be +issued per note. See 'GI.Ggit.Objects.Repository.repositoryNoteForeach'. +-} +type NoteCallback_WithClosures = + Ggit.OId.OId + {- ^ /@blobId@/: id of the blob containing the message. -} + -> Ggit.OId.OId + {- ^ /@annotatedObjectId@/: id of the git object being annotated. -} + -> Ptr () + {- ^ /@userData@/: user-suplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `NoteCallback_WithClosures`@. +noNoteCallback_WithClosures :: Maybe NoteCallback_WithClosures +noNoteCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_NoteCallback :: NoteCallback -> NoteCallback_WithClosures +drop_closures_NoteCallback _f blobId annotatedObjectId _ = _f blobId annotatedObjectId + +-- | Wrap the callback into a `GClosure`. +genClosure_NoteCallback :: MonadIO m => NoteCallback -> m (GClosure C_NoteCallback) +genClosure_NoteCallback cb = liftIO $ do + let cb' = drop_closures_NoteCallback cb + let cb'' = wrap_NoteCallback Nothing cb' + mk_NoteCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `NoteCallback` into a `C_NoteCallback`. +wrap_NoteCallback :: + Maybe (Ptr (FunPtr C_NoteCallback)) -> + NoteCallback_WithClosures -> + C_NoteCallback +wrap_NoteCallback funptrptr _cb blobId annotatedObjectId userData = do + B.ManagedPtr.withTransient Ggit.OId.OId blobId $ \blobId' -> do + B.ManagedPtr.withTransient Ggit.OId.OId annotatedObjectId $ \annotatedObjectId' -> do + result <- _cb blobId' annotatedObjectId' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback DiffSimilarityMetricSimilarityCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "score", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_a", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_b", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffSimilarityMetricSimilarityCallback = + Int32 -> + Ptr () -> + Ptr () -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "score", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_a", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_b", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricSimilarityCallback :: FunPtr C_DiffSimilarityMetricSimilarityCallback -> C_DiffSimilarityMetricSimilarityCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffSimilarityMetricSimilarityCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffSimilarityMetricSimilarityCallback + -> Int32 + -> Ptr () + -> Ptr () + -> Ptr () + -> m Int32 +dynamic_DiffSimilarityMetricSimilarityCallback __funPtr score signatureA signatureB userData = liftIO $ do + result <- (__dynamic_C_DiffSimilarityMetricSimilarityCallback __funPtr) score signatureA signatureB userData + return result + +-- | Generate a function pointer callable from C code, from a `C_DiffSimilarityMetricSimilarityCallback`. +foreign import ccall "wrapper" + mk_DiffSimilarityMetricSimilarityCallback :: C_DiffSimilarityMetricSimilarityCallback -> IO (FunPtr C_DiffSimilarityMetricSimilarityCallback) + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricSimilarityCallback = + Int32 + -> Ptr () + -> Ptr () + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricSimilarityCallback`@. +noDiffSimilarityMetricSimilarityCallback :: Maybe DiffSimilarityMetricSimilarityCallback +noDiffSimilarityMetricSimilarityCallback = Nothing + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricSimilarityCallback_WithClosures = + Int32 + -> Ptr () + -> Ptr () + -> Ptr () + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricSimilarityCallback_WithClosures`@. +noDiffSimilarityMetricSimilarityCallback_WithClosures :: Maybe DiffSimilarityMetricSimilarityCallback_WithClosures +noDiffSimilarityMetricSimilarityCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> DiffSimilarityMetricSimilarityCallback_WithClosures +drop_closures_DiffSimilarityMetricSimilarityCallback _f score signatureA signatureB _ = _f score signatureA signatureB + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffSimilarityMetricSimilarityCallback :: MonadIO m => DiffSimilarityMetricSimilarityCallback -> m (GClosure C_DiffSimilarityMetricSimilarityCallback) +genClosure_DiffSimilarityMetricSimilarityCallback cb = liftIO $ do + let cb' = drop_closures_DiffSimilarityMetricSimilarityCallback cb + let cb'' = wrap_DiffSimilarityMetricSimilarityCallback Nothing cb' + mk_DiffSimilarityMetricSimilarityCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffSimilarityMetricSimilarityCallback` into a `C_DiffSimilarityMetricSimilarityCallback`. +wrap_DiffSimilarityMetricSimilarityCallback :: + Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback)) -> + DiffSimilarityMetricSimilarityCallback_WithClosures -> + C_DiffSimilarityMetricSimilarityCallback +wrap_DiffSimilarityMetricSimilarityCallback funptrptr _cb score signatureA signatureB userData = do + result <- _cb score signatureA signatureB userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback DiffSimilarityMetricFreeSignatureCallback +-- -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "signature", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffSimilarityMetricFreeSignatureCallback = + Ptr () -> + Ptr () -> + IO () + +-- Args : [Arg {argCName = "signature", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricFreeSignatureCallback :: FunPtr C_DiffSimilarityMetricFreeSignatureCallback -> C_DiffSimilarityMetricFreeSignatureCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffSimilarityMetricFreeSignatureCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffSimilarityMetricFreeSignatureCallback + -> Ptr () + -> Ptr () + -> m () +dynamic_DiffSimilarityMetricFreeSignatureCallback __funPtr signature userData = liftIO $ do + (__dynamic_C_DiffSimilarityMetricFreeSignatureCallback __funPtr) signature userData + return () + +-- | Generate a function pointer callable from C code, from a `C_DiffSimilarityMetricFreeSignatureCallback`. +foreign import ccall "wrapper" + mk_DiffSimilarityMetricFreeSignatureCallback :: C_DiffSimilarityMetricFreeSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFreeSignatureCallback) + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricFreeSignatureCallback = + Ptr () + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricFreeSignatureCallback`@. +noDiffSimilarityMetricFreeSignatureCallback :: Maybe DiffSimilarityMetricFreeSignatureCallback +noDiffSimilarityMetricFreeSignatureCallback = Nothing + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricFreeSignatureCallback_WithClosures = + Ptr () + -> Ptr () + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricFreeSignatureCallback_WithClosures`@. +noDiffSimilarityMetricFreeSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFreeSignatureCallback_WithClosures +noDiffSimilarityMetricFreeSignatureCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback_WithClosures +drop_closures_DiffSimilarityMetricFreeSignatureCallback _f signature _ = _f signature + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffSimilarityMetricFreeSignatureCallback :: MonadIO m => DiffSimilarityMetricFreeSignatureCallback -> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback) +genClosure_DiffSimilarityMetricFreeSignatureCallback cb = liftIO $ do + let cb' = drop_closures_DiffSimilarityMetricFreeSignatureCallback cb + let cb'' = wrap_DiffSimilarityMetricFreeSignatureCallback Nothing cb' + mk_DiffSimilarityMetricFreeSignatureCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffSimilarityMetricFreeSignatureCallback` into a `C_DiffSimilarityMetricFreeSignatureCallback`. +wrap_DiffSimilarityMetricFreeSignatureCallback :: + Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)) -> + DiffSimilarityMetricFreeSignatureCallback_WithClosures -> + C_DiffSimilarityMetricFreeSignatureCallback +wrap_DiffSimilarityMetricFreeSignatureCallback funptrptr _cb signature userData = do + _cb signature userData + maybeReleaseFunPtr funptrptr + + +-- callback DiffSimilarityMetricFileSignatureCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fullpath", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffSimilarityMetricFileSignatureCallback = + Ptr Ggit.DiffFile.DiffFile -> + CString -> + Ptr () -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fullpath", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricFileSignatureCallback :: FunPtr C_DiffSimilarityMetricFileSignatureCallback -> C_DiffSimilarityMetricFileSignatureCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffSimilarityMetricFileSignatureCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffSimilarityMetricFileSignatureCallback + -> Ggit.DiffFile.DiffFile + -> T.Text + -> Ptr () + -> Ptr () + -> m Int32 +dynamic_DiffSimilarityMetricFileSignatureCallback __funPtr file fullpath out userData = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + fullpath' <- textToCString fullpath + result <- (__dynamic_C_DiffSimilarityMetricFileSignatureCallback __funPtr) file' fullpath' out userData + touchManagedPtr file + freeMem fullpath' + return result + +-- | Generate a function pointer callable from C code, from a `C_DiffSimilarityMetricFileSignatureCallback`. +foreign import ccall "wrapper" + mk_DiffSimilarityMetricFileSignatureCallback :: C_DiffSimilarityMetricFileSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFileSignatureCallback) + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricFileSignatureCallback = + Ggit.DiffFile.DiffFile + -> T.Text + -> Ptr () + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricFileSignatureCallback`@. +noDiffSimilarityMetricFileSignatureCallback :: Maybe DiffSimilarityMetricFileSignatureCallback +noDiffSimilarityMetricFileSignatureCallback = Nothing + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricFileSignatureCallback_WithClosures = + Ggit.DiffFile.DiffFile + -> T.Text + -> Ptr () + -> Ptr () + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricFileSignatureCallback_WithClosures`@. +noDiffSimilarityMetricFileSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures +noDiffSimilarityMetricFileSignatureCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricFileSignatureCallback_WithClosures +drop_closures_DiffSimilarityMetricFileSignatureCallback _f file fullpath out _ = _f file fullpath out + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffSimilarityMetricFileSignatureCallback :: MonadIO m => DiffSimilarityMetricFileSignatureCallback -> m (GClosure C_DiffSimilarityMetricFileSignatureCallback) +genClosure_DiffSimilarityMetricFileSignatureCallback cb = liftIO $ do + let cb' = drop_closures_DiffSimilarityMetricFileSignatureCallback cb + let cb'' = wrap_DiffSimilarityMetricFileSignatureCallback Nothing cb' + mk_DiffSimilarityMetricFileSignatureCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffSimilarityMetricFileSignatureCallback` into a `C_DiffSimilarityMetricFileSignatureCallback`. +wrap_DiffSimilarityMetricFileSignatureCallback :: + Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback)) -> + DiffSimilarityMetricFileSignatureCallback_WithClosures -> + C_DiffSimilarityMetricFileSignatureCallback +wrap_DiffSimilarityMetricFileSignatureCallback funptrptr _cb file fullpath out userData = do + B.ManagedPtr.withTransient Ggit.DiffFile.DiffFile file $ \file' -> do + fullpath' <- cstringToText fullpath + result <- _cb file' fullpath' out userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback DiffSimilarityMetricBufferSignatureCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buflen", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffSimilarityMetricBufferSignatureCallback = + Ptr Ggit.DiffFile.DiffFile -> + CString -> + Word64 -> + Ptr () -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buflen", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffSimilarityMetricBufferSignatureCallback :: FunPtr C_DiffSimilarityMetricBufferSignatureCallback -> C_DiffSimilarityMetricBufferSignatureCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffSimilarityMetricBufferSignatureCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffSimilarityMetricBufferSignatureCallback + -> Ggit.DiffFile.DiffFile + -> T.Text + -> Word64 + -> Ptr () + -> Ptr () + -> m Int32 +dynamic_DiffSimilarityMetricBufferSignatureCallback __funPtr file buf buflen out userData = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + buf' <- textToCString buf + result <- (__dynamic_C_DiffSimilarityMetricBufferSignatureCallback __funPtr) file' buf' buflen out userData + touchManagedPtr file + freeMem buf' + return result + +-- | Generate a function pointer callable from C code, from a `C_DiffSimilarityMetricBufferSignatureCallback`. +foreign import ccall "wrapper" + mk_DiffSimilarityMetricBufferSignatureCallback :: C_DiffSimilarityMetricBufferSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricBufferSignatureCallback) + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricBufferSignatureCallback = + Ggit.DiffFile.DiffFile + -> T.Text + -> Word64 + -> Ptr () + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricBufferSignatureCallback`@. +noDiffSimilarityMetricBufferSignatureCallback :: Maybe DiffSimilarityMetricBufferSignatureCallback +noDiffSimilarityMetricBufferSignatureCallback = Nothing + +{- | +/No description available in the introspection data./ +-} +type DiffSimilarityMetricBufferSignatureCallback_WithClosures = + Ggit.DiffFile.DiffFile + -> T.Text + -> Word64 + -> Ptr () + -> Ptr () + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffSimilarityMetricBufferSignatureCallback_WithClosures`@. +noDiffSimilarityMetricBufferSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures +noDiffSimilarityMetricBufferSignatureCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback_WithClosures +drop_closures_DiffSimilarityMetricBufferSignatureCallback _f file buf buflen out _ = _f file buf buflen out + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffSimilarityMetricBufferSignatureCallback :: MonadIO m => DiffSimilarityMetricBufferSignatureCallback -> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback) +genClosure_DiffSimilarityMetricBufferSignatureCallback cb = liftIO $ do + let cb' = drop_closures_DiffSimilarityMetricBufferSignatureCallback cb + let cb'' = wrap_DiffSimilarityMetricBufferSignatureCallback Nothing cb' + mk_DiffSimilarityMetricBufferSignatureCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffSimilarityMetricBufferSignatureCallback` into a `C_DiffSimilarityMetricBufferSignatureCallback`. +wrap_DiffSimilarityMetricBufferSignatureCallback :: + Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)) -> + DiffSimilarityMetricBufferSignatureCallback_WithClosures -> + C_DiffSimilarityMetricBufferSignatureCallback +wrap_DiffSimilarityMetricBufferSignatureCallback funptrptr _cb file buf buflen out userData = do + B.ManagedPtr.withTransient Ggit.DiffFile.DiffFile file $ \file' -> do + buf' <- cstringToText buf + result <- _cb file' buf' buflen out userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback DiffLineCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Called for each line.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffLineCallback = + Ptr Ggit.DiffDelta.DiffDelta -> + Ptr Ggit.DiffHunk.DiffHunk -> + Ptr Ggit.DiffLine.DiffLine -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffLineCallback :: FunPtr C_DiffLineCallback -> C_DiffLineCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffLineCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffLineCallback + -> Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffHunk.DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> Ggit.DiffLine.DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_DiffLineCallback __funPtr delta hunk line userData = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + hunk' <- unsafeManagedPtrGetPtr hunk + line' <- unsafeManagedPtrGetPtr line + result <- (__dynamic_C_DiffLineCallback __funPtr) delta' hunk' line' userData + touchManagedPtr delta + touchManagedPtr hunk + touchManagedPtr line + return result + +-- | Generate a function pointer callable from C code, from a `C_DiffLineCallback`. +foreign import ccall "wrapper" + mk_DiffLineCallback :: C_DiffLineCallback -> IO (FunPtr C_DiffLineCallback) + +{- | +Called for each line. +-} +type DiffLineCallback = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffHunk.DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> Ggit.DiffLine.DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffLineCallback`@. +noDiffLineCallback :: Maybe DiffLineCallback +noDiffLineCallback = Nothing + +{- | +Called for each line. +-} +type DiffLineCallback_WithClosures = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffHunk.DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> Ggit.DiffLine.DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffLineCallback_WithClosures`@. +noDiffLineCallback_WithClosures :: Maybe DiffLineCallback_WithClosures +noDiffLineCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffLineCallback :: DiffLineCallback -> DiffLineCallback_WithClosures +drop_closures_DiffLineCallback _f delta hunk line _ = _f delta hunk line + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffLineCallback :: MonadIO m => DiffLineCallback -> m (GClosure C_DiffLineCallback) +genClosure_DiffLineCallback cb = liftIO $ do + let cb' = drop_closures_DiffLineCallback cb + let cb'' = wrap_DiffLineCallback Nothing cb' + mk_DiffLineCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffLineCallback` into a `C_DiffLineCallback`. +wrap_DiffLineCallback :: + Maybe (Ptr (FunPtr C_DiffLineCallback)) -> + DiffLineCallback_WithClosures -> + C_DiffLineCallback +wrap_DiffLineCallback funptrptr _cb delta hunk line userData = do + B.ManagedPtr.withTransient Ggit.DiffDelta.DiffDelta delta $ \delta' -> do + B.ManagedPtr.withTransient Ggit.DiffHunk.DiffHunk hunk $ \hunk' -> do + B.ManagedPtr.withTransient Ggit.DiffLine.DiffLine line $ \line' -> do + result <- _cb delta' hunk' line' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback DiffHunkCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Called for each hunk.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffHunkCallback = + Ptr Ggit.DiffDelta.DiffDelta -> + Ptr Ggit.DiffHunk.DiffHunk -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffHunkCallback :: FunPtr C_DiffHunkCallback -> C_DiffHunkCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffHunkCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffHunkCallback + -> Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffHunk.DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_DiffHunkCallback __funPtr delta hunk userData = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + hunk' <- unsafeManagedPtrGetPtr hunk + result <- (__dynamic_C_DiffHunkCallback __funPtr) delta' hunk' userData + touchManagedPtr delta + touchManagedPtr hunk + return result + +-- | Generate a function pointer callable from C code, from a `C_DiffHunkCallback`. +foreign import ccall "wrapper" + mk_DiffHunkCallback :: C_DiffHunkCallback -> IO (FunPtr C_DiffHunkCallback) + +{- | +Called for each hunk. +-} +type DiffHunkCallback = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffHunk.DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffHunkCallback`@. +noDiffHunkCallback :: Maybe DiffHunkCallback +noDiffHunkCallback = Nothing + +{- | +Called for each hunk. +-} +type DiffHunkCallback_WithClosures = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffHunk.DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffHunkCallback_WithClosures`@. +noDiffHunkCallback_WithClosures :: Maybe DiffHunkCallback_WithClosures +noDiffHunkCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffHunkCallback :: DiffHunkCallback -> DiffHunkCallback_WithClosures +drop_closures_DiffHunkCallback _f delta hunk _ = _f delta hunk + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffHunkCallback :: MonadIO m => DiffHunkCallback -> m (GClosure C_DiffHunkCallback) +genClosure_DiffHunkCallback cb = liftIO $ do + let cb' = drop_closures_DiffHunkCallback cb + let cb'' = wrap_DiffHunkCallback Nothing cb' + mk_DiffHunkCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffHunkCallback` into a `C_DiffHunkCallback`. +wrap_DiffHunkCallback :: + Maybe (Ptr (FunPtr C_DiffHunkCallback)) -> + DiffHunkCallback_WithClosures -> + C_DiffHunkCallback +wrap_DiffHunkCallback funptrptr _cb delta hunk userData = do + B.ManagedPtr.withTransient Ggit.DiffDelta.DiffDelta delta $ \delta' -> do + B.ManagedPtr.withTransient Ggit.DiffHunk.DiffHunk hunk $ \hunk' -> do + result <- _cb delta' hunk' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback DiffFileCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the progress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Called for each file.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffFileCallback = + Ptr Ggit.DiffDelta.DiffDelta -> + CFloat -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the progress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffFileCallback :: FunPtr C_DiffFileCallback -> C_DiffFileCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffFileCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffFileCallback + -> Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Float + {- ^ /@progress@/: the progress. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_DiffFileCallback __funPtr delta progress userData = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + let progress' = realToFrac progress + result <- (__dynamic_C_DiffFileCallback __funPtr) delta' progress' userData + touchManagedPtr delta + return result + +-- | Generate a function pointer callable from C code, from a `C_DiffFileCallback`. +foreign import ccall "wrapper" + mk_DiffFileCallback :: C_DiffFileCallback -> IO (FunPtr C_DiffFileCallback) + +{- | +Called for each file. +-} +type DiffFileCallback = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Float + {- ^ /@progress@/: the progress. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffFileCallback`@. +noDiffFileCallback :: Maybe DiffFileCallback +noDiffFileCallback = Nothing + +{- | +Called for each file. +-} +type DiffFileCallback_WithClosures = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Float + {- ^ /@progress@/: the progress. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffFileCallback_WithClosures`@. +noDiffFileCallback_WithClosures :: Maybe DiffFileCallback_WithClosures +noDiffFileCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffFileCallback :: DiffFileCallback -> DiffFileCallback_WithClosures +drop_closures_DiffFileCallback _f delta progress _ = _f delta progress + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffFileCallback :: MonadIO m => DiffFileCallback -> m (GClosure C_DiffFileCallback) +genClosure_DiffFileCallback cb = liftIO $ do + let cb' = drop_closures_DiffFileCallback cb + let cb'' = wrap_DiffFileCallback Nothing cb' + mk_DiffFileCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffFileCallback` into a `C_DiffFileCallback`. +wrap_DiffFileCallback :: + Maybe (Ptr (FunPtr C_DiffFileCallback)) -> + DiffFileCallback_WithClosures -> + C_DiffFileCallback +wrap_DiffFileCallback funptrptr _cb delta progress userData = do + B.ManagedPtr.withTransient Ggit.DiffDelta.DiffDelta delta $ \delta' -> do + let progress' = realToFrac progress + result <- _cb delta' progress' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback DiffBinaryCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go continue or a #GgitError in case there was an error.", sinceVersion = Nothing}, args = [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binary", argType = TInterface (Name {namespace = "Ggit", name = "DiffBinary"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffBinary.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Called for each file.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_DiffBinaryCallback = + Ptr Ggit.DiffDelta.DiffDelta -> + Ptr Ggit.DiffBinary.DiffBinary -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binary", argType = TInterface (Name {namespace = "Ggit", name = "DiffBinary"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffBinary.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_DiffBinaryCallback :: FunPtr C_DiffBinaryCallback -> C_DiffBinaryCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_DiffBinaryCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_DiffBinaryCallback + -> Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffBinary.DiffBinary + {- ^ /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} +dynamic_DiffBinaryCallback __funPtr delta binary userData = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + binary' <- unsafeManagedPtrGetPtr binary + result <- (__dynamic_C_DiffBinaryCallback __funPtr) delta' binary' userData + touchManagedPtr delta + touchManagedPtr binary + return result + +-- | Generate a function pointer callable from C code, from a `C_DiffBinaryCallback`. +foreign import ccall "wrapper" + mk_DiffBinaryCallback :: C_DiffBinaryCallback -> IO (FunPtr C_DiffBinaryCallback) + +{- | +Called for each file. +-} +type DiffBinaryCallback = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffBinary.DiffBinary + {- ^ /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffBinaryCallback`@. +noDiffBinaryCallback :: Maybe DiffBinaryCallback +noDiffBinaryCallback = Nothing + +{- | +Called for each file. +-} +type DiffBinaryCallback_WithClosures = + Ggit.DiffDelta.DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> Ggit.DiffBinary.DiffBinary + {- ^ /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DiffBinaryCallback_WithClosures`@. +noDiffBinaryCallback_WithClosures :: Maybe DiffBinaryCallback_WithClosures +noDiffBinaryCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_DiffBinaryCallback :: DiffBinaryCallback -> DiffBinaryCallback_WithClosures +drop_closures_DiffBinaryCallback _f delta binary _ = _f delta binary + +-- | Wrap the callback into a `GClosure`. +genClosure_DiffBinaryCallback :: MonadIO m => DiffBinaryCallback -> m (GClosure C_DiffBinaryCallback) +genClosure_DiffBinaryCallback cb = liftIO $ do + let cb' = drop_closures_DiffBinaryCallback cb + let cb'' = wrap_DiffBinaryCallback Nothing cb' + mk_DiffBinaryCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `DiffBinaryCallback` into a `C_DiffBinaryCallback`. +wrap_DiffBinaryCallback :: + Maybe (Ptr (FunPtr C_DiffBinaryCallback)) -> + DiffBinaryCallback_WithClosures -> + C_DiffBinaryCallback +wrap_DiffBinaryCallback funptrptr _cb delta binary userData = do + B.ManagedPtr.withTransient Ggit.DiffDelta.DiffDelta delta $ \delta' -> do + B.ManagedPtr.withTransient Ggit.DiffBinary.DiffBinary binary $ \binary' -> do + result <- _cb delta' binary' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback CredAcquireCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the resource for which we are demanding a credential.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "username_from_url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The username that was embedded in a \"user@host\"\n remote url, or NULL if not included.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed_types", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask stating which cred types are OK to return.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cred", argType = TInterface (Name {namespace = "Ggit", name = "Cred"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "newly created credential object.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Signature of a function which acquires a credential object.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_CredAcquireCallback = + CString -> + CString -> + Word32 -> + Ptr Ggit.Cred.Cred -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the resource for which we are demanding a credential.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "username_from_url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The username that was embedded in a \"user@host\"\n remote url, or NULL if not included.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed_types", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask stating which cred types are OK to return.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cred", argType = TInterface (Name {namespace = "Ggit", name = "Cred"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "newly created credential object.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_CredAcquireCallback :: FunPtr C_CredAcquireCallback -> C_CredAcquireCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_CredAcquireCallback :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Cred.IsCred a) => + FunPtr C_CredAcquireCallback + -> T.Text + {- ^ /@url@/: the resource for which we are demanding a credential. -} + -> Maybe (T.Text) + {- ^ /@usernameFromUrl@/: The username that was embedded in a \"user/@host@/\" + remote url, or NULL if not included. -} + -> Word32 + {- ^ /@allowedTypes@/: a bitmask stating which cred types are OK to return. -} + -> a + {- ^ /@cred@/: newly created credential object. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 +dynamic_CredAcquireCallback __funPtr url usernameFromUrl allowedTypes cred userData = liftIO $ do + url' <- textToCString url + maybeUsernameFromUrl <- case usernameFromUrl of + Nothing -> return nullPtr + Just jUsernameFromUrl -> do + jUsernameFromUrl' <- textToCString jUsernameFromUrl + return jUsernameFromUrl' + cred' <- B.ManagedPtr.disownObject cred + result <- (__dynamic_C_CredAcquireCallback __funPtr) url' maybeUsernameFromUrl allowedTypes cred' userData + touchManagedPtr cred + freeMem url' + freeMem maybeUsernameFromUrl + return result + +-- | Generate a function pointer callable from C code, from a `C_CredAcquireCallback`. +foreign import ccall "wrapper" + mk_CredAcquireCallback :: C_CredAcquireCallback -> IO (FunPtr C_CredAcquireCallback) + +{- | +Signature of a function which acquires a credential object. +-} +type CredAcquireCallback = + T.Text + {- ^ /@url@/: the resource for which we are demanding a credential. -} + -> Maybe T.Text + {- ^ /@usernameFromUrl@/: The username that was embedded in a \"user/@host@/\" + remote url, or NULL if not included. -} + -> Word32 + {- ^ /@allowedTypes@/: a bitmask stating which cred types are OK to return. -} + -> Ggit.Cred.Cred + {- ^ /@cred@/: newly created credential object. -} + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CredAcquireCallback`@. +noCredAcquireCallback :: Maybe CredAcquireCallback +noCredAcquireCallback = Nothing + +{- | +Signature of a function which acquires a credential object. +-} +type CredAcquireCallback_WithClosures = + T.Text + {- ^ /@url@/: the resource for which we are demanding a credential. -} + -> Maybe T.Text + {- ^ /@usernameFromUrl@/: The username that was embedded in a \"user/@host@/\" + remote url, or NULL if not included. -} + -> Word32 + {- ^ /@allowedTypes@/: a bitmask stating which cred types are OK to return. -} + -> Ggit.Cred.Cred + {- ^ /@cred@/: newly created credential object. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CredAcquireCallback_WithClosures`@. +noCredAcquireCallback_WithClosures :: Maybe CredAcquireCallback_WithClosures +noCredAcquireCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_CredAcquireCallback :: CredAcquireCallback -> CredAcquireCallback_WithClosures +drop_closures_CredAcquireCallback _f url usernameFromUrl allowedTypes cred _ = _f url usernameFromUrl allowedTypes cred + +-- | Wrap the callback into a `GClosure`. +genClosure_CredAcquireCallback :: MonadIO m => CredAcquireCallback -> m (GClosure C_CredAcquireCallback) +genClosure_CredAcquireCallback cb = liftIO $ do + let cb' = drop_closures_CredAcquireCallback cb + let cb'' = wrap_CredAcquireCallback Nothing cb' + mk_CredAcquireCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `CredAcquireCallback` into a `C_CredAcquireCallback`. +wrap_CredAcquireCallback :: + Maybe (Ptr (FunPtr C_CredAcquireCallback)) -> + CredAcquireCallback_WithClosures -> + C_CredAcquireCallback +wrap_CredAcquireCallback funptrptr _cb url usernameFromUrl allowedTypes cred userData = do + url' <- cstringToText url + maybeUsernameFromUrl <- + if usernameFromUrl == nullPtr + then return Nothing + else do + usernameFromUrl' <- cstringToText usernameFromUrl + return $ Just usernameFromUrl' + cred' <- (wrapObject Ggit.Cred.Cred) cred + result <- _cb url' maybeUsernameFromUrl allowedTypes cred' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback ConfigMatchCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go for the next config value or a #GgitError in case there was\n an error.", sinceVersion = Nothing}, args = [Arg {argCName = "match_info", argType = TInterface (Name {namespace = "GLib", name = "MatchInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the match", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for retrieving values from a #GgitConfig\nusing a regular expression. See ggit_config_match_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ConfigMatchCallback = + Ptr GLib.MatchInfo.MatchInfo -> + CString -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "match_info", argType = TInterface (Name {namespace = "GLib", name = "MatchInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the match", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ConfigMatchCallback :: FunPtr C_ConfigMatchCallback -> C_ConfigMatchCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ConfigMatchCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_ConfigMatchCallback + -> GLib.MatchInfo.MatchInfo + {- ^ /@matchInfo@/: the match -} + -> T.Text + {- ^ /@value@/: the value -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go for the next config value or a 'GI.Ggit.Enums.Error' in case there was + an error. -} +dynamic_ConfigMatchCallback __funPtr matchInfo value userData = liftIO $ do + matchInfo' <- unsafeManagedPtrGetPtr matchInfo + value' <- textToCString value + result <- (__dynamic_C_ConfigMatchCallback __funPtr) matchInfo' value' userData + touchManagedPtr matchInfo + freeMem value' + return result + +-- | Generate a function pointer callable from C code, from a `C_ConfigMatchCallback`. +foreign import ccall "wrapper" + mk_ConfigMatchCallback :: C_ConfigMatchCallback -> IO (FunPtr C_ConfigMatchCallback) + +{- | +The type of the callback functions for retrieving values from a 'GI.Ggit.Objects.Config.Config' +using a regular expression. See 'GI.Ggit.Objects.Config.configMatchForeach'. +-} +type ConfigMatchCallback = + GLib.MatchInfo.MatchInfo + {- ^ /@matchInfo@/: the match -} + -> T.Text + {- ^ /@value@/: the value -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next config value or a 'GI.Ggit.Enums.Error' in case there was + an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ConfigMatchCallback`@. +noConfigMatchCallback :: Maybe ConfigMatchCallback +noConfigMatchCallback = Nothing + +{- | +The type of the callback functions for retrieving values from a 'GI.Ggit.Objects.Config.Config' +using a regular expression. See 'GI.Ggit.Objects.Config.configMatchForeach'. +-} +type ConfigMatchCallback_WithClosures = + GLib.MatchInfo.MatchInfo + {- ^ /@matchInfo@/: the match -} + -> T.Text + {- ^ /@value@/: the value -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next config value or a 'GI.Ggit.Enums.Error' in case there was + an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ConfigMatchCallback_WithClosures`@. +noConfigMatchCallback_WithClosures :: Maybe ConfigMatchCallback_WithClosures +noConfigMatchCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_ConfigMatchCallback :: ConfigMatchCallback -> ConfigMatchCallback_WithClosures +drop_closures_ConfigMatchCallback _f matchInfo value _ = _f matchInfo value + +-- | Wrap the callback into a `GClosure`. +genClosure_ConfigMatchCallback :: MonadIO m => ConfigMatchCallback -> m (GClosure C_ConfigMatchCallback) +genClosure_ConfigMatchCallback cb = liftIO $ do + let cb' = drop_closures_ConfigMatchCallback cb + let cb'' = wrap_ConfigMatchCallback Nothing cb' + mk_ConfigMatchCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `ConfigMatchCallback` into a `C_ConfigMatchCallback`. +wrap_ConfigMatchCallback :: + Maybe (Ptr (FunPtr C_ConfigMatchCallback)) -> + ConfigMatchCallback_WithClosures -> + C_ConfigMatchCallback +wrap_ConfigMatchCallback funptrptr _cb matchInfo value userData = do + B.ManagedPtr.withTransient GLib.MatchInfo.MatchInfo matchInfo $ \matchInfo' -> do + value' <- cstringToText value + result <- _cb matchInfo' value' userData + maybeReleaseFunPtr funptrptr + return result + + +-- callback ConfigCallback +-- -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "0 to go for the next config value or a #GgitError in case there was\n an error.", sinceVersion = Nothing}, args = [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the callback functions for retrieving values from a #GgitConfig.\nSee ggit_config_foreach().", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_ConfigCallback = + Ptr Ggit.ConfigEntry.ConfigEntry -> + Ptr () -> + IO Int32 + +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user-supplied data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_ConfigCallback :: FunPtr C_ConfigCallback -> C_ConfigCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_ConfigCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_ConfigCallback + -> Ggit.ConfigEntry.ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> m Int32 + {- ^ __Returns:__ 0 to go for the next config value or a 'GI.Ggit.Enums.Error' in case there was + an error. -} +dynamic_ConfigCallback __funPtr entry userData = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- (__dynamic_C_ConfigCallback __funPtr) entry' userData + touchManagedPtr entry + return result + +-- | Generate a function pointer callable from C code, from a `C_ConfigCallback`. +foreign import ccall "wrapper" + mk_ConfigCallback :: C_ConfigCallback -> IO (FunPtr C_ConfigCallback) + +{- | +The type of the callback functions for retrieving values from a 'GI.Ggit.Objects.Config.Config'. +See 'GI.Ggit.Objects.Config.configForeach'. +-} +type ConfigCallback = + Ggit.ConfigEntry.ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next config value or a 'GI.Ggit.Enums.Error' in case there was + an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ConfigCallback`@. +noConfigCallback :: Maybe ConfigCallback +noConfigCallback = Nothing + +{- | +The type of the callback functions for retrieving values from a 'GI.Ggit.Objects.Config.Config'. +See 'GI.Ggit.Objects.Config.configForeach'. +-} +type ConfigCallback_WithClosures = + Ggit.ConfigEntry.ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> Ptr () + {- ^ /@userData@/: user-supplied data. -} + -> IO Int32 + {- ^ __Returns:__ 0 to go for the next config value or a 'GI.Ggit.Enums.Error' in case there was + an error. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ConfigCallback_WithClosures`@. +noConfigCallback_WithClosures :: Maybe ConfigCallback_WithClosures +noConfigCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_ConfigCallback :: ConfigCallback -> ConfigCallback_WithClosures +drop_closures_ConfigCallback _f entry _ = _f entry + +-- | Wrap the callback into a `GClosure`. +genClosure_ConfigCallback :: MonadIO m => ConfigCallback -> m (GClosure C_ConfigCallback) +genClosure_ConfigCallback cb = liftIO $ do + let cb' = drop_closures_ConfigCallback cb + let cb'' = wrap_ConfigCallback Nothing cb' + mk_ConfigCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `ConfigCallback` into a `C_ConfigCallback`. +wrap_ConfigCallback :: + Maybe (Ptr (FunPtr C_ConfigCallback)) -> + ConfigCallback_WithClosures -> + C_ConfigCallback +wrap_ConfigCallback funptrptr _cb entry userData = do + B.ManagedPtr.withTransient Ggit.ConfigEntry.ConfigEntry entry $ \entry' -> do + result <- _cb entry' userData + maybeReleaseFunPtr funptrptr + return result + + + diff --git a/GI/Ggit/Enums.hs b/GI/Ggit/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Enums.hs @@ -0,0 +1,1331 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Enums + ( + + -- * Enumerations +-- ** BranchType #enum:BranchType# + + BranchType(..) , + + +-- ** CloneLocal #enum:CloneLocal# + + CloneLocal(..) , + + +-- ** ConfigLevel #enum:ConfigLevel# + + ConfigLevel(..) , + + +-- ** DeltaType #enum:DeltaType# + + DeltaType(..) , + + +-- ** DiffBinaryType #enum:DiffBinaryType# + + DiffBinaryType(..) , + + +-- ** DiffFormatType #enum:DiffFormatType# + + DiffFormatType(..) , + + +-- ** DiffLineType #enum:DiffLineType# + + DiffLineType(..) , + + +-- ** Direction #enum:Direction# + + Direction(..) , + + +-- ** Error #enum:Error# + + Error(..) , + catchError , + handleError , + + +-- ** FileMode #enum:FileMode# + + FileMode(..) , + + +-- ** MergeFileFavor #enum:MergeFileFavor# + + MergeFileFavor(..) , + + +-- ** PackbuilderStage #enum:PackbuilderStage# + + PackbuilderStage(..) , + + +-- ** ProxyType #enum:ProxyType# + + ProxyType(..) , + + +-- ** RebaseOperationType #enum:RebaseOperationType# + + RebaseOperationType(..) , + + +-- ** RefType #enum:RefType# + + RefType(..) , + + +-- ** RemoteCompletionType #enum:RemoteCompletionType# + + RemoteCompletionType(..) , + + +-- ** RemoteDownloadTagsType #enum:RemoteDownloadTagsType# + + RemoteDownloadTagsType(..) , + + +-- ** ResetType #enum:ResetType# + + ResetType(..) , + + +-- ** StatusShow #enum:StatusShow# + + StatusShow(..) , + + +-- ** SubmoduleIgnore #enum:SubmoduleIgnore# + + SubmoduleIgnore(..) , + + +-- ** SubmoduleRecurse #enum:SubmoduleRecurse# + + SubmoduleRecurse(..) , + + +-- ** SubmoduleUpdate #enum:SubmoduleUpdate# + + SubmoduleUpdate(..) , + + +-- ** TreeWalkMode #enum:TreeWalkMode# + + TreeWalkMode(..) , + + + + + ) 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 + + +-- Enum TreeWalkMode +{- | +Describes in which order a tree walk should be performed. +-} +data TreeWalkMode = + TreeWalkModePre + {- ^ + walk tree in pre-order + -} + | TreeWalkModePost + {- ^ + walk tree in post-order + -} + | AnotherTreeWalkMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum TreeWalkMode where + fromEnum TreeWalkModePre = 0 + fromEnum TreeWalkModePost = 1 + fromEnum (AnotherTreeWalkMode k) = k + + toEnum 0 = TreeWalkModePre + toEnum 1 = TreeWalkModePost + toEnum k = AnotherTreeWalkMode k + +instance P.Ord TreeWalkMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_tree_walk_mode_get_type" c_ggit_tree_walk_mode_get_type :: + IO GType + +instance BoxedEnum TreeWalkMode where + boxedEnumType _ = c_ggit_tree_walk_mode_get_type + +-- Enum SubmoduleUpdate +{- | +Describes how a submodule should be updated. +-} +data SubmoduleUpdate = + SubmoduleUpdateCheckout + {- ^ + checkout the submodule. + -} + | SubmoduleUpdateRebase + {- ^ + rebase the current branch onto the + commit recorded in the superproject. + -} + | SubmoduleUpdateMerge + {- ^ + merge the commit recorded in the + superproject into the current branch. + -} + | SubmoduleUpdateNone + {- ^ + do not update this submodule. + -} + | SubmoduleUpdateDefault + {- ^ + not used except as static initializer + when we don\'t want any particular update rule to be specified. + -} + | AnotherSubmoduleUpdate Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SubmoduleUpdate where + fromEnum SubmoduleUpdateCheckout = 1 + fromEnum SubmoduleUpdateRebase = 2 + fromEnum SubmoduleUpdateMerge = 3 + fromEnum SubmoduleUpdateNone = 4 + fromEnum SubmoduleUpdateDefault = 0 + fromEnum (AnotherSubmoduleUpdate k) = k + + toEnum 1 = SubmoduleUpdateCheckout + toEnum 2 = SubmoduleUpdateRebase + toEnum 3 = SubmoduleUpdateMerge + toEnum 4 = SubmoduleUpdateNone + toEnum 0 = SubmoduleUpdateDefault + toEnum k = AnotherSubmoduleUpdate k + +instance P.Ord SubmoduleUpdate where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_submodule_update_get_type" c_ggit_submodule_update_get_type :: + IO GType + +instance BoxedEnum SubmoduleUpdate where + boxedEnumType _ = c_ggit_submodule_update_get_type + +-- Enum SubmoduleRecurse +{- | +Options for submodule recurse. +Represents the value of @submodule.$name.fetchRecurseSubmodules@ +-} +data SubmoduleRecurse = + SubmoduleRecurseNo + {- ^ + do no recurse into submodules. + -} + | SubmoduleRecurseYes + {- ^ + recurse into submodules. + -} + | SubmoduleRecurseOndemand + {- ^ + recurse into submodules only when + commit not already in local clone. + -} + | AnotherSubmoduleRecurse Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SubmoduleRecurse where + fromEnum SubmoduleRecurseNo = 0 + fromEnum SubmoduleRecurseYes = 1 + fromEnum SubmoduleRecurseOndemand = 2 + fromEnum (AnotherSubmoduleRecurse k) = k + + toEnum 0 = SubmoduleRecurseNo + toEnum 1 = SubmoduleRecurseYes + toEnum 2 = SubmoduleRecurseOndemand + toEnum k = AnotherSubmoduleRecurse k + +instance P.Ord SubmoduleRecurse where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_submodule_recurse_get_type" c_ggit_submodule_recurse_get_type :: + IO GType + +instance BoxedEnum SubmoduleRecurse where + boxedEnumType _ = c_ggit_submodule_recurse_get_type + +-- Enum SubmoduleIgnore +{- | +Describes which submodules should be ignored. +-} +data SubmoduleIgnore = + SubmoduleIgnoreUnspecified + {- ^ + reset to on-disk value. + -} + | SubmoduleIgnoreNone + {- ^ + don\'t ignore any change. + -} + | SubmoduleIgnoreUntracked + {- ^ + ignore untracked files. + -} + | SubmoduleIgnoreDirty + {- ^ + ignore changes in the working directory. + -} + | SubmoduleIgnoreAll + {- ^ + never check if the submodule is dirty. + -} + | AnotherSubmoduleIgnore Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SubmoduleIgnore where + fromEnum SubmoduleIgnoreUnspecified = -1 + fromEnum SubmoduleIgnoreNone = 1 + fromEnum SubmoduleIgnoreUntracked = 2 + fromEnum SubmoduleIgnoreDirty = 3 + fromEnum SubmoduleIgnoreAll = 4 + fromEnum (AnotherSubmoduleIgnore k) = k + + toEnum -1 = SubmoduleIgnoreUnspecified + toEnum 1 = SubmoduleIgnoreNone + toEnum 2 = SubmoduleIgnoreUntracked + toEnum 3 = SubmoduleIgnoreDirty + toEnum 4 = SubmoduleIgnoreAll + toEnum k = AnotherSubmoduleIgnore k + +instance P.Ord SubmoduleIgnore where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_submodule_ignore_get_type" c_ggit_submodule_ignore_get_type :: + IO GType + +instance BoxedEnum SubmoduleIgnore where + boxedEnumType _ = c_ggit_submodule_ignore_get_type + +-- Enum StatusShow +{- | +Show options for @/ggit_repository_file_status_foreach/@. Determines which +files are included in the status. +-} +data StatusShow = + StatusShowIndexAndWorkdir + {- ^ + receive one callback for each file, + even if the file is in both the index and the workdir (combining 'GI.Ggit.Flags.StatusFlags'). + -} + | StatusShowIndexOnly + {- ^ + only receive callbacks for files in the index. + -} + | StatusShowWorkdirOnly + {- ^ + only receive callbacks for files in the workdir. + -} + | AnotherStatusShow Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum StatusShow where + fromEnum StatusShowIndexAndWorkdir = 0 + fromEnum StatusShowIndexOnly = 1 + fromEnum StatusShowWorkdirOnly = 2 + fromEnum (AnotherStatusShow k) = k + + toEnum 0 = StatusShowIndexAndWorkdir + toEnum 1 = StatusShowIndexOnly + toEnum 2 = StatusShowWorkdirOnly + toEnum k = AnotherStatusShow k + +instance P.Ord StatusShow where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_status_show_get_type" c_ggit_status_show_get_type :: + IO GType + +instance BoxedEnum StatusShow where + boxedEnumType _ = c_ggit_status_show_get_type + +-- Enum ResetType +{- | +Describes the type of reset to perform. +-} +data ResetType = + ResetTypeSoft + {- ^ + The head will be moved to the commit. + -} + | ResetTypeMixed + {- ^ + the head will be moved to the commit and the index + will be replaced with the content of the commit tree. + -} + | ResetTypeHard + {- ^ + MIXED plus changes in working tree discarded. + -} + | AnotherResetType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ResetType where + fromEnum ResetTypeSoft = 1 + fromEnum ResetTypeMixed = 2 + fromEnum ResetTypeHard = 3 + fromEnum (AnotherResetType k) = k + + toEnum 1 = ResetTypeSoft + toEnum 2 = ResetTypeMixed + toEnum 3 = ResetTypeHard + toEnum k = AnotherResetType k + +instance P.Ord ResetType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_reset_type_get_type" c_ggit_reset_type_get_type :: + IO GType + +instance BoxedEnum ResetType where + boxedEnumType _ = c_ggit_reset_type_get_type + +-- Enum RemoteDownloadTagsType +{- | +Automatic tag following option + +Lets us select the --tags option to use. +-} +data RemoteDownloadTagsType = + RemoteDownloadTagsTypeUnspecified + {- ^ + Use the setting from the configuration. + -} + | RemoteDownloadTagsTypeAuto + {- ^ + Ask the server for tags pointing to objects we\'re already + downloading. + -} + | RemoteDownloadTagsTypeNone + {- ^ + Don\'t ask for any tags beyond the refspecs. + -} + | RemoteDownloadTagsTypeAll + {- ^ + Ask for the all the tags. + -} + | AnotherRemoteDownloadTagsType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RemoteDownloadTagsType where + fromEnum RemoteDownloadTagsTypeUnspecified = 0 + fromEnum RemoteDownloadTagsTypeAuto = 1 + fromEnum RemoteDownloadTagsTypeNone = 2 + fromEnum RemoteDownloadTagsTypeAll = 3 + fromEnum (AnotherRemoteDownloadTagsType k) = k + + toEnum 0 = RemoteDownloadTagsTypeUnspecified + toEnum 1 = RemoteDownloadTagsTypeAuto + toEnum 2 = RemoteDownloadTagsTypeNone + toEnum 3 = RemoteDownloadTagsTypeAll + toEnum k = AnotherRemoteDownloadTagsType k + +instance P.Ord RemoteDownloadTagsType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_remote_download_tags_type_get_type" c_ggit_remote_download_tags_type_get_type :: + IO GType + +instance BoxedEnum RemoteDownloadTagsType where + boxedEnumType _ = c_ggit_remote_download_tags_type_get_type + +-- Enum RemoteCompletionType +{- | +Argument to the completion callback which tells it which operation finished. +-} +data RemoteCompletionType = + RemoteCompletionTypeDownload + {- ^ + download. + -} + | RemoteCompletionTypeIndexing + {- ^ + indexing. + -} + | RemoteCompletionTypeError + {- ^ + error. + -} + | AnotherRemoteCompletionType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RemoteCompletionType where + fromEnum RemoteCompletionTypeDownload = 0 + fromEnum RemoteCompletionTypeIndexing = 1 + fromEnum RemoteCompletionTypeError = 2 + fromEnum (AnotherRemoteCompletionType k) = k + + toEnum 0 = RemoteCompletionTypeDownload + toEnum 1 = RemoteCompletionTypeIndexing + toEnum 2 = RemoteCompletionTypeError + toEnum k = AnotherRemoteCompletionType k + +instance P.Ord RemoteCompletionType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_remote_completion_type_get_type" c_ggit_remote_completion_type_get_type :: + IO GType + +instance BoxedEnum RemoteCompletionType where + boxedEnumType _ = c_ggit_remote_completion_type_get_type + +-- Enum RefType +{- | +Describes the type a reference is. +-} +data RefType = + RefTypeInvalid + {- ^ + An invalid reference. + -} + | RefTypeOid + {- ^ + A reference which points at an object id. + -} + | RefTypeSymbolic + {- ^ + A reference which points at another reference. + -} + | RefTypeListall + {- ^ + All reference types. + -} + | AnotherRefType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RefType where + fromEnum RefTypeInvalid = 0 + fromEnum RefTypeOid = 1 + fromEnum RefTypeSymbolic = 2 + fromEnum RefTypeListall = 3 + fromEnum (AnotherRefType k) = k + + toEnum 0 = RefTypeInvalid + toEnum 1 = RefTypeOid + toEnum 2 = RefTypeSymbolic + toEnum 3 = RefTypeListall + toEnum k = AnotherRefType k + +instance P.Ord RefType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_ref_type_get_type" c_ggit_ref_type_get_type :: + IO GType + +instance BoxedEnum RefType where + boxedEnumType _ = c_ggit_ref_type_get_type + +-- Enum RebaseOperationType +{- | +Type of rebase operation in-progress. +-} +data RebaseOperationType = + RebaseOperationTypePick + {- ^ + The given commit is to be cherry-picked. + The client should commit the changes and continue if there are no conflicts. + -} + | RebaseOperationTypeReword + {- ^ + The given commit is to be cherry-picked, + but the client should prompt the user to provide an updated commit message. + -} + | RebaseOperationTypeEdit + {- ^ + The given commit is to be cherry-picked, + but the client should stop to allow the user to edit the changes before + committing them. + -} + | RebaseOperationTypeSquash + {- ^ + The given commit is to be squashed into + the previous commit. The commit message will be merged with the previous message. + -} + | RebaseOperationTypeFixup + {- ^ + The given commit is to be squashed into the + previous commit. The commit message from this commit will be discarded. + -} + | RebaseOperationTypeExec + {- ^ + No commit will be cherry-picked. + The client should run the given command and (if successful) continue. + -} + | AnotherRebaseOperationType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RebaseOperationType where + fromEnum RebaseOperationTypePick = 0 + fromEnum RebaseOperationTypeReword = 1 + fromEnum RebaseOperationTypeEdit = 2 + fromEnum RebaseOperationTypeSquash = 3 + fromEnum RebaseOperationTypeFixup = 4 + fromEnum RebaseOperationTypeExec = 5 + fromEnum (AnotherRebaseOperationType k) = k + + toEnum 0 = RebaseOperationTypePick + toEnum 1 = RebaseOperationTypeReword + toEnum 2 = RebaseOperationTypeEdit + toEnum 3 = RebaseOperationTypeSquash + toEnum 4 = RebaseOperationTypeFixup + toEnum 5 = RebaseOperationTypeExec + toEnum k = AnotherRebaseOperationType k + +instance P.Ord RebaseOperationType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_rebase_operation_type_get_type" c_ggit_rebase_operation_type_get_type :: + IO GType + +instance BoxedEnum RebaseOperationType where + boxedEnumType _ = c_ggit_rebase_operation_type_get_type + +-- Enum ProxyType +{- | +The type of proxy to use. +-} +data ProxyType = + ProxyTypeNone + {- ^ + Do not attempt to connect through a proxy. + -} + | ProxyTypeAuto + {- ^ + Try to auto-detect the proxy from the git configuration. + -} + | ProxyTypeSpecified + {- ^ + Connect via the URL given in the options. + -} + | AnotherProxyType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ProxyType where + fromEnum ProxyTypeNone = 0 + fromEnum ProxyTypeAuto = 1 + fromEnum ProxyTypeSpecified = 2 + fromEnum (AnotherProxyType k) = k + + toEnum 0 = ProxyTypeNone + toEnum 1 = ProxyTypeAuto + toEnum 2 = ProxyTypeSpecified + toEnum k = AnotherProxyType k + +instance P.Ord ProxyType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_proxy_type_get_type" c_ggit_proxy_type_get_type :: + IO GType + +instance BoxedEnum ProxyType where + boxedEnumType _ = c_ggit_proxy_type_get_type + +-- Enum PackbuilderStage +{- | +Valid stages for pack building. +-} +data PackbuilderStage = + PackbuilderStageAddingObjects + {- ^ + adding objects. + -} + | PackbuilderStageDeltafication + {- ^ + deltafication. + -} + | AnotherPackbuilderStage Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PackbuilderStage where + fromEnum PackbuilderStageAddingObjects = 0 + fromEnum PackbuilderStageDeltafication = 1 + fromEnum (AnotherPackbuilderStage k) = k + + toEnum 0 = PackbuilderStageAddingObjects + toEnum 1 = PackbuilderStageDeltafication + toEnum k = AnotherPackbuilderStage k + +instance P.Ord PackbuilderStage where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_packbuilder_stage_get_type" c_ggit_packbuilder_stage_get_type :: + IO GType + +instance BoxedEnum PackbuilderStage where + boxedEnumType _ = c_ggit_packbuilder_stage_get_type + +-- Enum MergeFileFavor +{- | +/No description available in the introspection data./ +-} +data MergeFileFavor = + MergeFileFavorNormal + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFavorOurs + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFavorTheirs + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFavorUnion + {- ^ + /No description available in the introspection data./ + -} + | AnotherMergeFileFavor Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum MergeFileFavor where + fromEnum MergeFileFavorNormal = 0 + fromEnum MergeFileFavorOurs = 1 + fromEnum MergeFileFavorTheirs = 2 + fromEnum MergeFileFavorUnion = 3 + fromEnum (AnotherMergeFileFavor k) = k + + toEnum 0 = MergeFileFavorNormal + toEnum 1 = MergeFileFavorOurs + toEnum 2 = MergeFileFavorTheirs + toEnum 3 = MergeFileFavorUnion + toEnum k = AnotherMergeFileFavor k + +instance P.Ord MergeFileFavor where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_merge_file_favor_get_type" c_ggit_merge_file_favor_get_type :: + IO GType + +instance BoxedEnum MergeFileFavor where + boxedEnumType _ = c_ggit_merge_file_favor_get_type + +-- Enum FileMode +{- | +/No description available in the introspection data./ +-} +data FileMode = + FileModeUnreadable + {- ^ + /No description available in the introspection data./ + -} + | FileModeTree + {- ^ + /No description available in the introspection data./ + -} + | FileModeBlob + {- ^ + /No description available in the introspection data./ + -} + | FileModeBlobExecutable + {- ^ + /No description available in the introspection data./ + -} + | FileModeLink + {- ^ + /No description available in the introspection data./ + -} + | FileModeCommit + {- ^ + /No description available in the introspection data./ + -} + | AnotherFileMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FileMode where + fromEnum FileModeUnreadable = 0 + fromEnum FileModeTree = 16384 + fromEnum FileModeBlob = 33188 + fromEnum FileModeBlobExecutable = 33261 + fromEnum FileModeLink = 40960 + fromEnum FileModeCommit = 57344 + fromEnum (AnotherFileMode k) = k + + toEnum 0 = FileModeUnreadable + toEnum 16384 = FileModeTree + toEnum 33188 = FileModeBlob + toEnum 33261 = FileModeBlobExecutable + toEnum 40960 = FileModeLink + toEnum 57344 = FileModeCommit + toEnum k = AnotherFileMode k + +instance P.Ord FileMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_file_mode_get_type" c_ggit_file_mode_get_type :: + IO GType + +instance BoxedEnum FileMode where + boxedEnumType _ = c_ggit_file_mode_get_type + +-- Enum Error +{- | +Error codes for the @/GGIT_ERROR/@ error domain. +-} +data Error = + ErrorGitError + {- ^ + A generic error for when an operation fails. + -} + | ErrorNotfound + {- ^ + Input does not exist in the scope searched. + -} + | ErrorExists + {- ^ + A reference with this name already exists. + -} + | ErrorAmbiguous + {- ^ + The given error is ambiguous. + -} + | ErrorBufs + {- ^ + The buffer is too short. + -} + | ErrorPassthrough + {- ^ + Skip and passthrough the given ODB backend. + -} + | ErrorIterover + {- ^ + The iteration has finished. + -} + | AnotherError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum Error where + fromEnum ErrorGitError = -1 + fromEnum ErrorNotfound = -3 + fromEnum ErrorExists = -4 + fromEnum ErrorAmbiguous = -5 + fromEnum ErrorBufs = -6 + fromEnum ErrorPassthrough = -30 + fromEnum ErrorIterover = -31 + fromEnum (AnotherError k) = k + + toEnum -1 = ErrorGitError + toEnum -3 = ErrorNotfound + toEnum -4 = ErrorExists + toEnum -5 = ErrorAmbiguous + toEnum -6 = ErrorBufs + toEnum -30 = ErrorPassthrough + toEnum -31 = ErrorIterover + toEnum k = AnotherError k + +instance P.Ord Error where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass Error where + gerrorClassDomain _ = "ggit-error" + +-- | Catch exceptions of type `Error`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchError :: + IO a -> + (Error -> GErrorMessage -> IO a) -> + IO a +catchError = catchGErrorJustDomain + +-- | Handle exceptions of type `Error`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleError :: + (Error -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleError = handleGErrorJustDomain + +foreign import ccall "ggit_error_get_type" c_ggit_error_get_type :: + IO GType + +instance BoxedEnum Error where + boxedEnumType _ = c_ggit_error_get_type + +-- Enum Direction +{- | +/No description available in the introspection data./ +-} +data Direction = + DirectionFetch + {- ^ + /No description available in the introspection data./ + -} + | DirectionPush + {- ^ + /No description available in the introspection data./ + -} + | AnotherDirection Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum Direction where + fromEnum DirectionFetch = 0 + fromEnum DirectionPush = 1 + fromEnum (AnotherDirection k) = k + + toEnum 0 = DirectionFetch + toEnum 1 = DirectionPush + toEnum k = AnotherDirection k + +instance P.Ord Direction where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_direction_get_type" c_ggit_direction_get_type :: + IO GType + +instance BoxedEnum Direction where + boxedEnumType _ = c_ggit_direction_get_type + +-- Enum DiffLineType +{- | +These values describe where a line came from and will be passed to +the 'GI.Ggit.Callbacks.DiffLineCallback' when iterating over a diff. + +The @/GGIT_DIFF_LINE_FILE_HDR/@, @/GGIT_DIFF_LINE_HUNK_HDR/@ and +@/GGIT_DIFF_LINE_BINARY/@ values are only sent when the diff is being printed. +-} +data DiffLineType = + DiffLineTypeContext + {- ^ + line is part of the context. + -} + | DiffLineTypeAddition + {- ^ + line that was added. + -} + | DiffLineTypeDeletion + {- ^ + line that was removed. + -} + | DiffLineTypeContextEofnl + {- ^ + Both files have no LF at end. + -} + | DiffLineTypeAddEofnl + {- ^ + LF was added at end of file. + -} + | DiffLineTypeDelEofnl + {- ^ + LF was removed at end of file. + -} + | DiffLineTypeFileHdr + {- ^ + the file header. + -} + | DiffLineTypeHunkHdr + {- ^ + the hunk header. + -} + | DiffLineTypeBinary + {- ^ + is binary. + -} + | AnotherDiffLineType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffLineType where + fromEnum DiffLineTypeContext = 32 + fromEnum DiffLineTypeAddition = 43 + fromEnum DiffLineTypeDeletion = 45 + fromEnum DiffLineTypeContextEofnl = 61 + fromEnum DiffLineTypeAddEofnl = 62 + fromEnum DiffLineTypeDelEofnl = 60 + fromEnum DiffLineTypeFileHdr = 70 + fromEnum DiffLineTypeHunkHdr = 72 + fromEnum DiffLineTypeBinary = 66 + fromEnum (AnotherDiffLineType k) = k + + toEnum 32 = DiffLineTypeContext + toEnum 43 = DiffLineTypeAddition + toEnum 45 = DiffLineTypeDeletion + toEnum 61 = DiffLineTypeContextEofnl + toEnum 62 = DiffLineTypeAddEofnl + toEnum 60 = DiffLineTypeDelEofnl + toEnum 70 = DiffLineTypeFileHdr + toEnum 72 = DiffLineTypeHunkHdr + toEnum 66 = DiffLineTypeBinary + toEnum k = AnotherDiffLineType k + +instance P.Ord DiffLineType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_diff_line_type_get_type" c_ggit_diff_line_type_get_type :: + IO GType + +instance BoxedEnum DiffLineType where + boxedEnumType _ = c_ggit_diff_line_type_get_type + +-- Enum DiffFormatType +{- | +Possible output formats for diff data. +-} +data DiffFormatType = + DiffFormatTypePatch + {- ^ + full git diff. + -} + | DiffFormatTypePatchHeader + {- ^ + just the file headers of patch. + -} + | DiffFormatTypeRaw + {- ^ + like git diff --raw. + -} + | DiffFormatTypeNameOnly + {- ^ + like git diff --name-only. + -} + | DiffFormatTypeNameStatus + {- ^ + like git diff --name-status. + -} + | AnotherDiffFormatType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffFormatType where + fromEnum DiffFormatTypePatch = 1 + fromEnum DiffFormatTypePatchHeader = 2 + fromEnum DiffFormatTypeRaw = 3 + fromEnum DiffFormatTypeNameOnly = 4 + fromEnum DiffFormatTypeNameStatus = 5 + fromEnum (AnotherDiffFormatType k) = k + + toEnum 1 = DiffFormatTypePatch + toEnum 2 = DiffFormatTypePatchHeader + toEnum 3 = DiffFormatTypeRaw + toEnum 4 = DiffFormatTypeNameOnly + toEnum 5 = DiffFormatTypeNameStatus + toEnum k = AnotherDiffFormatType k + +instance P.Ord DiffFormatType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_diff_format_type_get_type" c_ggit_diff_format_type_get_type :: + IO GType + +instance BoxedEnum DiffFormatType where + boxedEnumType _ = c_ggit_diff_format_type_get_type + +-- Enum DiffBinaryType +{- | +When producing a binary diff, the binary data returned will be +either the deflated full (\"literal\") contents of the file, or +the deflated binary delta between the two sides (whichever is +smaller). +-} +data DiffBinaryType = + DiffBinaryTypeNone + {- ^ + /No description available in the introspection data./ + -} + | DiffBinaryTypeLiteral + {- ^ + /No description available in the introspection data./ + -} + | DiffBinaryTypeDelta + {- ^ + /No description available in the introspection data./ + -} + | AnotherDiffBinaryType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffBinaryType where + fromEnum DiffBinaryTypeNone = 0 + fromEnum DiffBinaryTypeLiteral = 1 + fromEnum DiffBinaryTypeDelta = 2 + fromEnum (AnotherDiffBinaryType k) = k + + toEnum 0 = DiffBinaryTypeNone + toEnum 1 = DiffBinaryTypeLiteral + toEnum 2 = DiffBinaryTypeDelta + toEnum k = AnotherDiffBinaryType k + +instance P.Ord DiffBinaryType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_diff_binary_type_get_type" c_ggit_diff_binary_type_get_type :: + IO GType + +instance BoxedEnum DiffBinaryType where + boxedEnumType _ = c_ggit_diff_binary_type_get_type + +-- Enum DeltaType +{- | +Describes the type of change the delta is. +-} +data DeltaType = + DeltaTypeUnmodified + {- ^ + unmodified. + -} + | DeltaTypeAdded + {- ^ + added. + -} + | DeltaTypeDeleted + {- ^ + deleted. + -} + | DeltaTypeModified + {- ^ + modified. + -} + | DeltaTypeRenamed + {- ^ + renamed. + -} + | DeltaTypeCopied + {- ^ + copied. + -} + | DeltaTypeIgnored + {- ^ + ignored. + -} + | DeltaTypeUntracked + {- ^ + untracked. + -} + | AnotherDeltaType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DeltaType where + fromEnum DeltaTypeUnmodified = 0 + fromEnum DeltaTypeAdded = 1 + fromEnum DeltaTypeDeleted = 2 + fromEnum DeltaTypeModified = 3 + fromEnum DeltaTypeRenamed = 4 + fromEnum DeltaTypeCopied = 5 + fromEnum DeltaTypeIgnored = 6 + fromEnum DeltaTypeUntracked = 7 + fromEnum (AnotherDeltaType k) = k + + toEnum 0 = DeltaTypeUnmodified + toEnum 1 = DeltaTypeAdded + toEnum 2 = DeltaTypeDeleted + toEnum 3 = DeltaTypeModified + toEnum 4 = DeltaTypeRenamed + toEnum 5 = DeltaTypeCopied + toEnum 6 = DeltaTypeIgnored + toEnum 7 = DeltaTypeUntracked + toEnum k = AnotherDeltaType k + +instance P.Ord DeltaType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_delta_type_get_type" c_ggit_delta_type_get_type :: + IO GType + +instance BoxedEnum DeltaType where + boxedEnumType _ = c_ggit_delta_type_get_type + +-- Enum ConfigLevel +{- | +Priority level of a config file. +These priority levels correspond to the natural escalation logic +(from higher to lower) when searching for config entries in git.git. +-} +data ConfigLevel = + ConfigLevelProgramdata + {- ^ + System-wide on Windows, for compatibility with portable git. + -} + | ConfigLevelSystem + {- ^ + System-wide configuration file. + -} + | ConfigLevelXdg + {- ^ + XDG compatible configuration file (.config\/git\/config). + -} + | ConfigLevelGlobal + {- ^ + User-specific configuration file, also called Global configuration file. + -} + | ConfigLevelLocal + {- ^ + Repository specific configuration file. + -} + | ConfigLevelApp + {- ^ + Application specific configuration file; freely defined by applications. + -} + | ConfigLevelHighest + {- ^ + Represents the highest level of a config file. + -} + | AnotherConfigLevel Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ConfigLevel where + fromEnum ConfigLevelProgramdata = 1 + fromEnum ConfigLevelSystem = 2 + fromEnum ConfigLevelXdg = 3 + fromEnum ConfigLevelGlobal = 4 + fromEnum ConfigLevelLocal = 5 + fromEnum ConfigLevelApp = 6 + fromEnum ConfigLevelHighest = -1 + fromEnum (AnotherConfigLevel k) = k + + toEnum 1 = ConfigLevelProgramdata + toEnum 2 = ConfigLevelSystem + toEnum 3 = ConfigLevelXdg + toEnum 4 = ConfigLevelGlobal + toEnum 5 = ConfigLevelLocal + toEnum 6 = ConfigLevelApp + toEnum -1 = ConfigLevelHighest + toEnum k = AnotherConfigLevel k + +instance P.Ord ConfigLevel where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_config_level_get_type" c_ggit_config_level_get_type :: + IO GType + +instance BoxedEnum ConfigLevel where + boxedEnumType _ = c_ggit_config_level_get_type + +-- Enum CloneLocal +{- | +/No description available in the introspection data./ +-} +data CloneLocal = + CloneLocalAuto + {- ^ + /No description available in the introspection data./ + -} + | CloneLocalLocal + {- ^ + /No description available in the introspection data./ + -} + | CloneLocalNoLocal + {- ^ + /No description available in the introspection data./ + -} + | CloneLocalNoLinks + {- ^ + /No description available in the introspection data./ + -} + | AnotherCloneLocal Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CloneLocal where + fromEnum CloneLocalAuto = 0 + fromEnum CloneLocalLocal = 1 + fromEnum CloneLocalNoLocal = 2 + fromEnum CloneLocalNoLinks = 3 + fromEnum (AnotherCloneLocal k) = k + + toEnum 0 = CloneLocalAuto + toEnum 1 = CloneLocalLocal + toEnum 2 = CloneLocalNoLocal + toEnum 3 = CloneLocalNoLinks + toEnum k = AnotherCloneLocal k + +instance P.Ord CloneLocal where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_clone_local_get_type" c_ggit_clone_local_get_type :: + IO GType + +instance BoxedEnum CloneLocal where + boxedEnumType _ = c_ggit_clone_local_get_type + +-- Enum BranchType +{- | +The type of a branch. +-} +data BranchType = + BranchTypeLocal + {- ^ + specifies a local branch. + -} + | BranchTypeRemote + {- ^ + specifies a remote branch. + -} + | AnotherBranchType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum BranchType where + fromEnum BranchTypeLocal = 1 + fromEnum BranchTypeRemote = 2 + fromEnum (AnotherBranchType k) = k + + toEnum 1 = BranchTypeLocal + toEnum 2 = BranchTypeRemote + toEnum k = AnotherBranchType k + +instance P.Ord BranchType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_branch_type_get_type" c_ggit_branch_type_get_type :: + IO GType + +instance BoxedEnum BranchType where + boxedEnumType _ = c_ggit_branch_type_get_type + + diff --git a/GI/Ggit/Enums.hs-boot b/GI/Ggit/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Enums.hs-boot @@ -0,0 +1,93 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Enums 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 + +data TreeWalkMode +instance P.Enum TreeWalkMode where +instance BoxedEnum TreeWalkMode where +data SubmoduleUpdate +instance P.Enum SubmoduleUpdate where +instance BoxedEnum SubmoduleUpdate where +data SubmoduleRecurse +instance P.Enum SubmoduleRecurse where +instance BoxedEnum SubmoduleRecurse where +data SubmoduleIgnore +instance P.Enum SubmoduleIgnore where +instance BoxedEnum SubmoduleIgnore where +data StatusShow +instance P.Enum StatusShow where +instance BoxedEnum StatusShow where +data ResetType +instance P.Enum ResetType where +instance BoxedEnum ResetType where +data RemoteDownloadTagsType +instance P.Enum RemoteDownloadTagsType where +instance BoxedEnum RemoteDownloadTagsType where +data RemoteCompletionType +instance P.Enum RemoteCompletionType where +instance BoxedEnum RemoteCompletionType where +data RefType +instance P.Enum RefType where +instance BoxedEnum RefType where +data RebaseOperationType +instance P.Enum RebaseOperationType where +instance BoxedEnum RebaseOperationType where +data ProxyType +instance P.Enum ProxyType where +instance BoxedEnum ProxyType where +data PackbuilderStage +instance P.Enum PackbuilderStage where +instance BoxedEnum PackbuilderStage where +data MergeFileFavor +instance P.Enum MergeFileFavor where +instance BoxedEnum MergeFileFavor where +data FileMode +instance P.Enum FileMode where +instance BoxedEnum FileMode where +data Error +instance P.Enum Error where +instance BoxedEnum Error where +data Direction +instance P.Enum Direction where +instance BoxedEnum Direction where +data DiffLineType +instance P.Enum DiffLineType where +instance BoxedEnum DiffLineType where +data DiffFormatType +instance P.Enum DiffFormatType where +instance BoxedEnum DiffFormatType where +data DiffBinaryType +instance P.Enum DiffBinaryType where +instance BoxedEnum DiffBinaryType where +data DeltaType +instance P.Enum DeltaType where +instance BoxedEnum DeltaType where +data ConfigLevel +instance P.Enum ConfigLevel where +instance BoxedEnum ConfigLevel where +data CloneLocal +instance P.Enum CloneLocal where +instance BoxedEnum CloneLocal where +data BranchType +instance P.Enum BranchType where +instance BoxedEnum BranchType where diff --git a/GI/Ggit/Flags.hs b/GI/Ggit/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Flags.hs @@ -0,0 +1,1522 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Flags + ( + + -- * Flags +-- ** AttributeCheckFlags #flag:AttributeCheckFlags# + + AttributeCheckFlags(..) , + + +-- ** BlameFlags #flag:BlameFlags# + + BlameFlags(..) , + + +-- ** CheckoutNotifyFlags #flag:CheckoutNotifyFlags# + + CheckoutNotifyFlags(..) , + + +-- ** CheckoutStrategy #flag:CheckoutStrategy# + + CheckoutStrategy(..) , + + +-- ** CreateFlags #flag:CreateFlags# + + CreateFlags(..) , + + +-- ** Credtype #flag:Credtype# + + Credtype(..) , + + +-- ** DiffFindFlags #flag:DiffFindFlags# + + DiffFindFlags(..) , + + +-- ** DiffFlag #flag:DiffFlag# + + DiffFlag(..) , + + +-- ** DiffFormatEmailFlags #flag:DiffFormatEmailFlags# + + DiffFormatEmailFlags(..) , + + +-- ** DiffOption #flag:DiffOption# + + DiffOption(..) , + + +-- ** FeatureFlags #flag:FeatureFlags# + + FeatureFlags(..) , + + +-- ** MergeFileFlags #flag:MergeFileFlags# + + MergeFileFlags(..) , + + +-- ** MergeFlags #flag:MergeFlags# + + MergeFlags(..) , + + +-- ** SortMode #flag:SortMode# + + SortMode(..) , + + +-- ** StashFlags #flag:StashFlags# + + StashFlags(..) , + + +-- ** StatusFlags #flag:StatusFlags# + + StatusFlags(..) , + + +-- ** StatusOption #flag:StatusOption# + + StatusOption(..) , + + +-- ** SubmoduleStatus #flag:SubmoduleStatus# + + SubmoduleStatus(..) , + + + + + ) 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 + + +-- Flags SubmoduleStatus +{- | +FIXME +-} +data SubmoduleStatus = + SubmoduleStatusInHead + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusInIndex + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusInConfig + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusInWd + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusIndexAdded + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusIndexDeleted + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusIndexModified + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusWdUninitialized + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusWdAdded + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusWdDeleted + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusWdModified + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusWdIndexModified + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusWdWdModified + {- ^ + /No description available in the introspection data./ + -} + | SubmoduleStatusWdUntracked + {- ^ + /No description available in the introspection data./ + -} + | AnotherSubmoduleStatus Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SubmoduleStatus where + fromEnum SubmoduleStatusInHead = 1 + fromEnum SubmoduleStatusInIndex = 2 + fromEnum SubmoduleStatusInConfig = 4 + fromEnum SubmoduleStatusInWd = 8 + fromEnum SubmoduleStatusIndexAdded = 16 + fromEnum SubmoduleStatusIndexDeleted = 32 + fromEnum SubmoduleStatusIndexModified = 64 + fromEnum SubmoduleStatusWdUninitialized = 128 + fromEnum SubmoduleStatusWdAdded = 256 + fromEnum SubmoduleStatusWdDeleted = 512 + fromEnum SubmoduleStatusWdModified = 1024 + fromEnum SubmoduleStatusWdIndexModified = 2048 + fromEnum SubmoduleStatusWdWdModified = 4096 + fromEnum SubmoduleStatusWdUntracked = 8192 + fromEnum (AnotherSubmoduleStatus k) = k + + toEnum 1 = SubmoduleStatusInHead + toEnum 2 = SubmoduleStatusInIndex + toEnum 4 = SubmoduleStatusInConfig + toEnum 8 = SubmoduleStatusInWd + toEnum 16 = SubmoduleStatusIndexAdded + toEnum 32 = SubmoduleStatusIndexDeleted + toEnum 64 = SubmoduleStatusIndexModified + toEnum 128 = SubmoduleStatusWdUninitialized + toEnum 256 = SubmoduleStatusWdAdded + toEnum 512 = SubmoduleStatusWdDeleted + toEnum 1024 = SubmoduleStatusWdModified + toEnum 2048 = SubmoduleStatusWdIndexModified + toEnum 4096 = SubmoduleStatusWdWdModified + toEnum 8192 = SubmoduleStatusWdUntracked + toEnum k = AnotherSubmoduleStatus k + +instance P.Ord SubmoduleStatus where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_submodule_status_get_type" c_ggit_submodule_status_get_type :: + IO GType + +instance BoxedFlags SubmoduleStatus where + boxedFlagsType _ = c_ggit_submodule_status_get_type + +instance IsGFlag SubmoduleStatus + +-- Flags StatusOption +{- | +GGIT_STATUS_OPTION_INCLUDE_UNTRACKED: include untracked files (default). +GGIT_STATUS_OPTION_INCLUDE_IGNORED: include ignored files (default). +GGIT_STATUS_OPTION_INCLUDE_UNMODIFIED: include unmodified files. +GGIT_STATUS_OPTION_EXCLUDE_SUBMODULES: exclude submodules. +GGIT_STATUS_OPTION_RECURSE_UNTRACKED_DIRS: search untracked directories recursively (default). +GGIT_STATUS_OPTION_DISABLE_PATHSPEC_MATCH: do not match path specifications. +GGIT_STATUS_OPTION_RECURSE_IGNORED_DIRS: search ignored directories recursively. +GGIT_STATUS_OPTION_RENAMES_HEAD_TO_INDEX: indicates that rename detection +should be processed between the head and the index and enables +the GIT_STATUS_INDEX_RENAMED as a possible status flag. +GGIT_STATUS_OPTION_RENAMES_INDEX_TO_WORKDIR: indicates tha rename +detection should be run between the index and the working directory +and enabled GIT_STATUS_WT_RENAMED as a possible status flag. +GGIT_STATUS_OPTION_SORT_CASE_SENSITIVELY: sort case sensitive. +GGIT_STATUS_OPTION_SORT_CASE_INSENSITIVELY: sort case insensitive. +GGIT_STATUS_OPTION_DEFAULT: default flags. +Status options specified when using @/ggit_repository_file_status_foreach/@. +-} +data StatusOption = + StatusOptionIncludeUntracked + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionIncludeIgnored + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionIncludeUnmodified + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionExcludeSubmodules + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionRecurseUntrackedDirs + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionDisablePathspecMatch + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionRecurseIgnoredDirs + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionRenamesHeadToIndex + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionRenamesIndexToWorkdir + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionSortCaseSensitively + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionSortCaseInsensitively + {- ^ + /No description available in the introspection data./ + -} + | StatusOptionDefault + {- ^ + /No description available in the introspection data./ + -} + | AnotherStatusOption Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum StatusOption where + fromEnum StatusOptionIncludeUntracked = 1 + fromEnum StatusOptionIncludeIgnored = 2 + fromEnum StatusOptionIncludeUnmodified = 4 + fromEnum StatusOptionExcludeSubmodules = 8 + fromEnum StatusOptionRecurseUntrackedDirs = 16 + fromEnum StatusOptionDisablePathspecMatch = 32 + fromEnum StatusOptionRecurseIgnoredDirs = 64 + fromEnum StatusOptionRenamesHeadToIndex = 128 + fromEnum StatusOptionRenamesIndexToWorkdir = 256 + fromEnum StatusOptionSortCaseSensitively = 512 + fromEnum StatusOptionSortCaseInsensitively = 1024 + fromEnum StatusOptionDefault = 19 + fromEnum (AnotherStatusOption k) = k + + toEnum 1 = StatusOptionIncludeUntracked + toEnum 2 = StatusOptionIncludeIgnored + toEnum 4 = StatusOptionIncludeUnmodified + toEnum 8 = StatusOptionExcludeSubmodules + toEnum 16 = StatusOptionRecurseUntrackedDirs + toEnum 32 = StatusOptionDisablePathspecMatch + toEnum 64 = StatusOptionRecurseIgnoredDirs + toEnum 128 = StatusOptionRenamesHeadToIndex + toEnum 256 = StatusOptionRenamesIndexToWorkdir + toEnum 512 = StatusOptionSortCaseSensitively + toEnum 1024 = StatusOptionSortCaseInsensitively + toEnum 19 = StatusOptionDefault + toEnum k = AnotherStatusOption k + +instance P.Ord StatusOption where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_status_option_get_type" c_ggit_status_option_get_type :: + IO GType + +instance BoxedFlags StatusOption where + boxedFlagsType _ = c_ggit_status_option_get_type + +instance IsGFlag StatusOption + +-- Flags StatusFlags +{- | +Describes a file\'s status. +-} +data StatusFlags = + StatusFlagsCurrent + {- ^ + file is current. + -} + | StatusFlagsIndexNew + {- ^ + file in index is new. + -} + | StatusFlagsIndexModified + {- ^ + file in index is modified. + -} + | StatusFlagsIndexDeleted + {- ^ + file in index is deleted. + -} + | StatusFlagsIndexRenamed + {- ^ + /No description available in the introspection data./ + -} + | StatusFlagsIndexTypechange + {- ^ + /No description available in the introspection data./ + -} + | StatusFlagsWorkingTreeNew + {- ^ + file in working tree is new. + -} + | StatusFlagsWorkingTreeModified + {- ^ + file in working tree is modified. + -} + | StatusFlagsWorkingTreeDeleted + {- ^ + file in working tree is deleted. + -} + | StatusFlagsWorkingTreeTypechange + {- ^ + /No description available in the introspection data./ + -} + | StatusFlagsIgnored + {- ^ + file is ignored. + -} + | AnotherStatusFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum StatusFlags where + fromEnum StatusFlagsCurrent = 0 + fromEnum StatusFlagsIndexNew = 1 + fromEnum StatusFlagsIndexModified = 2 + fromEnum StatusFlagsIndexDeleted = 4 + fromEnum StatusFlagsIndexRenamed = 8 + fromEnum StatusFlagsIndexTypechange = 16 + fromEnum StatusFlagsWorkingTreeNew = 128 + fromEnum StatusFlagsWorkingTreeModified = 256 + fromEnum StatusFlagsWorkingTreeDeleted = 512 + fromEnum StatusFlagsWorkingTreeTypechange = 1024 + fromEnum StatusFlagsIgnored = 16384 + fromEnum (AnotherStatusFlags k) = k + + toEnum 0 = StatusFlagsCurrent + toEnum 1 = StatusFlagsIndexNew + toEnum 2 = StatusFlagsIndexModified + toEnum 4 = StatusFlagsIndexDeleted + toEnum 8 = StatusFlagsIndexRenamed + toEnum 16 = StatusFlagsIndexTypechange + toEnum 128 = StatusFlagsWorkingTreeNew + toEnum 256 = StatusFlagsWorkingTreeModified + toEnum 512 = StatusFlagsWorkingTreeDeleted + toEnum 1024 = StatusFlagsWorkingTreeTypechange + toEnum 16384 = StatusFlagsIgnored + toEnum k = AnotherStatusFlags k + +instance P.Ord StatusFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_status_flags_get_type" c_ggit_status_flags_get_type :: + IO GType + +instance BoxedFlags StatusFlags where + boxedFlagsType _ = c_ggit_status_flags_get_type + +instance IsGFlag StatusFlags + +-- Flags StashFlags +{- | +Describes how a stash should be applied. +-} +data StashFlags = + StashFlagsDefault + {- ^ + default stash. + -} + | StashFlagsKeepIndex + {- ^ + All changes already added to the index + are left intact in the working directory. + -} + | StashFlagsIncludeUntracked + {- ^ + All untracked files are also stashed and then + cleaned up from the working directory. + -} + | StashFlagsIncludeIgnored + {- ^ + All ignored files are also stashed and then + cleaned up from the working directory. + -} + | AnotherStashFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum StashFlags where + fromEnum StashFlagsDefault = 0 + fromEnum StashFlagsKeepIndex = 1 + fromEnum StashFlagsIncludeUntracked = 2 + fromEnum StashFlagsIncludeIgnored = 4 + fromEnum (AnotherStashFlags k) = k + + toEnum 0 = StashFlagsDefault + toEnum 1 = StashFlagsKeepIndex + toEnum 2 = StashFlagsIncludeUntracked + toEnum 4 = StashFlagsIncludeIgnored + toEnum k = AnotherStashFlags k + +instance P.Ord StashFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_stash_flags_get_type" c_ggit_stash_flags_get_type :: + IO GType + +instance BoxedFlags StashFlags where + boxedFlagsType _ = c_ggit_stash_flags_get_type + +instance IsGFlag StashFlags + +-- Flags SortMode +{- | +The type of sorting mode for the revision walker. +-} +data SortMode = + SortModeNone + {- ^ + Sorts the repository contents in no particular ordering; + this sorting is arbitrary, implementation-specific + and subject to change at any time. + -} + | SortModeTopological + {- ^ + Sorts the repository contents in topological order + (parents before children); this sorting mode + can be combined with time sorting. + -} + | SortModeTime + {- ^ + Sort the repository contents by commit time; + this sorting mode can be combined with + topological sorting. + -} + | SortModeReverse + {- ^ + Iterate through the repository contents in reverse + order; this sorting mode can be combined with + any of the above. + -} + | AnotherSortMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SortMode where + fromEnum SortModeNone = 0 + fromEnum SortModeTopological = 1 + fromEnum SortModeTime = 2 + fromEnum SortModeReverse = 4 + fromEnum (AnotherSortMode k) = k + + toEnum 0 = SortModeNone + toEnum 1 = SortModeTopological + toEnum 2 = SortModeTime + toEnum 4 = SortModeReverse + toEnum k = AnotherSortMode k + +instance P.Ord SortMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_sort_mode_get_type" c_ggit_sort_mode_get_type :: + IO GType + +instance BoxedFlags SortMode where + boxedFlagsType _ = c_ggit_sort_mode_get_type + +instance IsGFlag SortMode + +-- Flags MergeFlags +{- | +/No description available in the introspection data./ +-} +data MergeFlags = + MergeFlagsFindRenames + {- ^ + detect renames that occur between the common + ancestor and the \"ours\" side or the common ancestor and the \"theirs\" side. + This will enable the ability to merge between a modified and renamed file. + -} + | MergeFlagsFailOnConflict + {- ^ + If a conflict occurs, exit immediately instead + of attempting to continue resolving conflicts. The merge operation will + fail with /@gGITEMERGECONFLICT@/ and no index will be returned. + -} + | MergeFlagsSkipReuc + {- ^ + do not write the REUC extension on the generated index. + -} + | MergeFlagsNoRecursive + {- ^ + If the commits being merged have multiple merge bases, + do not build a recursive merge base (by merging the multiple merge bases), + instead simply use the first base. This flag provides a similar + merge base to @git-merge-resolve@. + -} + | AnotherMergeFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum MergeFlags where + fromEnum MergeFlagsFindRenames = 1 + fromEnum MergeFlagsFailOnConflict = 2 + fromEnum MergeFlagsSkipReuc = 4 + fromEnum MergeFlagsNoRecursive = 8 + fromEnum (AnotherMergeFlags k) = k + + toEnum 1 = MergeFlagsFindRenames + toEnum 2 = MergeFlagsFailOnConflict + toEnum 4 = MergeFlagsSkipReuc + toEnum 8 = MergeFlagsNoRecursive + toEnum k = AnotherMergeFlags k + +instance P.Ord MergeFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_merge_flags_get_type" c_ggit_merge_flags_get_type :: + IO GType + +instance BoxedFlags MergeFlags where + boxedFlagsType _ = c_ggit_merge_flags_get_type + +instance IsGFlag MergeFlags + +-- Flags MergeFileFlags +{- | +GGIT_MERGE_FILE_DEFAULT: Defaults. +GGIT_MERGE_FILE_STYLE_MERGE: Create standard conflicted merge files. +GGIT_MERGE_FILE_STYLE_DIFF3: Create diff3-style files. +GGIT_MERGE_FILE_SIMPLIFY_ALNUM: Condense non-alphanumeric regions for simplified diff file. +GGIT_MERGE_FILE_IGNORE_WHITESPACE: Ignore all whitespace. +GGIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE: Ignore changes in amount of whitespace. +GGIT_MERGE_FILE_IGNORE_WHITESPACE_EOL: Ignore whitespace at end of line. +GGIT_MERGE_FILE_DIFF_PATIENCE: Use the \"patience diff\" algorithm. +GGIT_MERGE_FILE_DIFF_MINIMAL: Take extra time to find minimal diff. +-} +data MergeFileFlags = + MergeFileFlagsDefault + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsStyleMerge + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsStyleDiff3 + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsSimplifyAlnum + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsIgnoreWhitespace + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsIgnoreWhitespaceChange + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsIgnoreWhitespaceEol + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsDiffPatience + {- ^ + /No description available in the introspection data./ + -} + | MergeFileFlagsDiffMinimal + {- ^ + /No description available in the introspection data./ + -} + | AnotherMergeFileFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum MergeFileFlags where + fromEnum MergeFileFlagsDefault = 0 + fromEnum MergeFileFlagsStyleMerge = 1 + fromEnum MergeFileFlagsStyleDiff3 = 2 + fromEnum MergeFileFlagsSimplifyAlnum = 4 + fromEnum MergeFileFlagsIgnoreWhitespace = 8 + fromEnum MergeFileFlagsIgnoreWhitespaceChange = 16 + fromEnum MergeFileFlagsIgnoreWhitespaceEol = 32 + fromEnum MergeFileFlagsDiffPatience = 64 + fromEnum MergeFileFlagsDiffMinimal = 128 + fromEnum (AnotherMergeFileFlags k) = k + + toEnum 0 = MergeFileFlagsDefault + toEnum 1 = MergeFileFlagsStyleMerge + toEnum 2 = MergeFileFlagsStyleDiff3 + toEnum 4 = MergeFileFlagsSimplifyAlnum + toEnum 8 = MergeFileFlagsIgnoreWhitespace + toEnum 16 = MergeFileFlagsIgnoreWhitespaceChange + toEnum 32 = MergeFileFlagsIgnoreWhitespaceEol + toEnum 64 = MergeFileFlagsDiffPatience + toEnum 128 = MergeFileFlagsDiffMinimal + toEnum k = AnotherMergeFileFlags k + +instance P.Ord MergeFileFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_merge_file_flags_get_type" c_ggit_merge_file_flags_get_type :: + IO GType + +instance BoxedFlags MergeFileFlags where + boxedFlagsType _ = c_ggit_merge_file_flags_get_type + +instance IsGFlag MergeFileFlags + +-- Flags FeatureFlags +{- | +/No description available in the introspection data./ +-} +data FeatureFlags = + FeatureFlagsThreads + {- ^ + /No description available in the introspection data./ + -} + | FeatureFlagsHttps + {- ^ + /No description available in the introspection data./ + -} + | FeatureFlagsSsh + {- ^ + /No description available in the introspection data./ + -} + | AnotherFeatureFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FeatureFlags where + fromEnum FeatureFlagsThreads = 1 + fromEnum FeatureFlagsHttps = 2 + fromEnum FeatureFlagsSsh = 4 + fromEnum (AnotherFeatureFlags k) = k + + toEnum 1 = FeatureFlagsThreads + toEnum 2 = FeatureFlagsHttps + toEnum 4 = FeatureFlagsSsh + toEnum k = AnotherFeatureFlags k + +instance P.Ord FeatureFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_feature_flags_get_type" c_ggit_feature_flags_get_type :: + IO GType + +instance BoxedFlags FeatureFlags where + boxedFlagsType _ = c_ggit_feature_flags_get_type + +instance IsGFlag FeatureFlags + +-- Flags DiffOption +{- | +How the diff should be generated. +-} +data DiffOption = + DiffOptionNormal + {- ^ + normal. + -} + | DiffOptionReverse + {- ^ + reverse the sides of the diff. + -} + | DiffOptionIncludeIgnored + {- ^ + include ignored files. + -} + | DiffOptionRecurseIgnoredDirs + {- ^ + also add all files under ignored dirs. + -} + | DiffOptionIncludeUntracked + {- ^ + include untracked files. + -} + | DiffOptionRecurseUntrackedDirs + {- ^ + recurse to untracked directories. + -} + | DiffOptionIncludeUnmodified + {- ^ + include unmodified files. + -} + | DiffOptionIncludeTypechange + {- ^ + enable generation of typechange detal records. + -} + | DiffOptionIncludeTypechangeTrees + {- ^ + try to label tree transitions as type changes. + -} + | DiffOptionIgnoreFileMode + {- ^ + ignore file mode changes. + -} + | DiffOptionIgnoreSubmodules + {- ^ + ignore submodules. + -} + | DiffOptionIgnoreCase + {- ^ + use case insensitive filename comparison. + -} + | DiffOptionDisablePathspecMatch + {- ^ + use exact path matching. + -} + | DiffOptionSkipBinaryCheck + {- ^ + disable updating the binary flag in delta records. + -} + | DiffOptionEnableFastUntrackedDirs + {- ^ + immediately label untracked directories as + untracked, without checking inside. + -} + | DiffOptionForceText + {- ^ + force text. + -} + | DiffOptionForceBinary + {- ^ + treat all files as binary, disabling text diffs. + -} + | DiffOptionIgnoreWhitespace + {- ^ + ignore whitespace. + -} + | DiffOptionIgnoreWhitespaceChange + {- ^ + ignore whitespace change. + -} + | DiffOptionIgnoreWhitespaceEol + {- ^ + ignore whitespace at end-of-line. + -} + | DiffOptionShowUntrackedContent + {- ^ + include content of untracked files. + this implies GGIT_DIFF_INCLUDE_UNTRACKED but not GGIT_DIFF_RECURSE_UNTRACKED_DIRS. + -} + | DiffOptionShowUnmodified + {- ^ + show unmodified files. + -} + | DiffOptionPatience + {- ^ + generate using the \"patience diff\" algorithm. + -} + | DiffOptionMinimal + {- ^ + take extra time to find minimal diff. + -} + | DiffOptionShowBinary + {- ^ + include deflate\/delta information for binary files. + -} + | AnotherDiffOption Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffOption where + fromEnum DiffOptionNormal = 0 + fromEnum DiffOptionReverse = 1 + fromEnum DiffOptionIncludeIgnored = 2 + fromEnum DiffOptionRecurseIgnoredDirs = 4 + fromEnum DiffOptionIncludeUntracked = 8 + fromEnum DiffOptionRecurseUntrackedDirs = 16 + fromEnum DiffOptionIncludeUnmodified = 32 + fromEnum DiffOptionIncludeTypechange = 64 + fromEnum DiffOptionIncludeTypechangeTrees = 128 + fromEnum DiffOptionIgnoreFileMode = 256 + fromEnum DiffOptionIgnoreSubmodules = 512 + fromEnum DiffOptionIgnoreCase = 1024 + fromEnum DiffOptionDisablePathspecMatch = 4096 + fromEnum DiffOptionSkipBinaryCheck = 8192 + fromEnum DiffOptionEnableFastUntrackedDirs = 16384 + fromEnum DiffOptionForceText = 1048576 + fromEnum DiffOptionForceBinary = 2097152 + fromEnum DiffOptionIgnoreWhitespace = 4194304 + fromEnum DiffOptionIgnoreWhitespaceChange = 8388608 + fromEnum DiffOptionIgnoreWhitespaceEol = 16777216 + fromEnum DiffOptionShowUntrackedContent = 33554432 + fromEnum DiffOptionShowUnmodified = 67108864 + fromEnum DiffOptionPatience = 268435456 + fromEnum DiffOptionMinimal = 536870912 + fromEnum DiffOptionShowBinary = 1073741824 + fromEnum (AnotherDiffOption k) = k + + toEnum 0 = DiffOptionNormal + toEnum 1 = DiffOptionReverse + toEnum 2 = DiffOptionIncludeIgnored + toEnum 4 = DiffOptionRecurseIgnoredDirs + toEnum 8 = DiffOptionIncludeUntracked + toEnum 16 = DiffOptionRecurseUntrackedDirs + toEnum 32 = DiffOptionIncludeUnmodified + toEnum 64 = DiffOptionIncludeTypechange + toEnum 128 = DiffOptionIncludeTypechangeTrees + toEnum 256 = DiffOptionIgnoreFileMode + toEnum 512 = DiffOptionIgnoreSubmodules + toEnum 1024 = DiffOptionIgnoreCase + toEnum 4096 = DiffOptionDisablePathspecMatch + toEnum 8192 = DiffOptionSkipBinaryCheck + toEnum 16384 = DiffOptionEnableFastUntrackedDirs + toEnum 1048576 = DiffOptionForceText + toEnum 2097152 = DiffOptionForceBinary + toEnum 4194304 = DiffOptionIgnoreWhitespace + toEnum 8388608 = DiffOptionIgnoreWhitespaceChange + toEnum 16777216 = DiffOptionIgnoreWhitespaceEol + toEnum 33554432 = DiffOptionShowUntrackedContent + toEnum 67108864 = DiffOptionShowUnmodified + toEnum 268435456 = DiffOptionPatience + toEnum 536870912 = DiffOptionMinimal + toEnum 1073741824 = DiffOptionShowBinary + toEnum k = AnotherDiffOption k + +instance P.Ord DiffOption where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_diff_option_get_type" c_ggit_diff_option_get_type :: + IO GType + +instance BoxedFlags DiffOption where + boxedFlagsType _ = c_ggit_diff_option_get_type + +instance IsGFlag DiffOption + +-- Flags DiffFormatEmailFlags +{- | +/No description available in the introspection data./ +-} +data DiffFormatEmailFlags = + DiffFormatEmailFlagsNone + {- ^ + /No description available in the introspection data./ + -} + | DiffFormatEmailFlagsExcludeSubjectPatchMarker + {- ^ + /No description available in the introspection data./ + -} + | AnotherDiffFormatEmailFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffFormatEmailFlags where + fromEnum DiffFormatEmailFlagsNone = 0 + fromEnum DiffFormatEmailFlagsExcludeSubjectPatchMarker = 1 + fromEnum (AnotherDiffFormatEmailFlags k) = k + + toEnum 0 = DiffFormatEmailFlagsNone + toEnum 1 = DiffFormatEmailFlagsExcludeSubjectPatchMarker + toEnum k = AnotherDiffFormatEmailFlags k + +instance P.Ord DiffFormatEmailFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_diff_format_email_flags_get_type" c_ggit_diff_format_email_flags_get_type :: + IO GType + +instance BoxedFlags DiffFormatEmailFlags where + boxedFlagsType _ = c_ggit_diff_format_email_flags_get_type + +instance IsGFlag DiffFormatEmailFlags + +-- Flags DiffFlag +{- | +Describes the diff file and\/or delta flags +-} +data DiffFlag = + DiffFlagBinary + {- ^ + if the file is binary. + -} + | DiffFlagNotBinary + {- ^ + if the file is not binary. + -} + | DiffFlagValidId + {- ^ + if the ID is valid. + -} + | AnotherDiffFlag Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffFlag where + fromEnum DiffFlagBinary = 1 + fromEnum DiffFlagNotBinary = 2 + fromEnum DiffFlagValidId = 4 + fromEnum (AnotherDiffFlag k) = k + + toEnum 1 = DiffFlagBinary + toEnum 2 = DiffFlagNotBinary + toEnum 4 = DiffFlagValidId + toEnum k = AnotherDiffFlag k + +instance P.Ord DiffFlag where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_diff_flag_get_type" c_ggit_diff_flag_get_type :: + IO GType + +instance BoxedFlags DiffFlag where + boxedFlagsType _ = c_ggit_diff_flag_get_type + +instance IsGFlag DiffFlag + +-- Flags DiffFindFlags +{- | +/No description available in the introspection data./ +-} +data DiffFindFlags = + DiffFindFlagsFindByConfig + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindRenames + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindRenamesFromRewrites + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindCopies + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindCopiesFromUnmodified + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindRewrites + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsBreakRewrites + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindAndBreakRewrites + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindForUntracked + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindAll + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindIgnoreLeadingWhitespace + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindIgnoreWhitespace + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindDontIgnoreWhitespace + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindExactMatchOnly + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsBreakRewritesForRenamesOnly + {- ^ + /No description available in the introspection data./ + -} + | DiffFindFlagsFindRemoveUnmodified + {- ^ + /No description available in the introspection data./ + -} + | AnotherDiffFindFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DiffFindFlags where + fromEnum DiffFindFlagsFindByConfig = 0 + fromEnum DiffFindFlagsFindRenames = 1 + fromEnum DiffFindFlagsFindRenamesFromRewrites = 2 + fromEnum DiffFindFlagsFindCopies = 4 + fromEnum DiffFindFlagsFindCopiesFromUnmodified = 8 + fromEnum DiffFindFlagsFindRewrites = 16 + fromEnum DiffFindFlagsBreakRewrites = 32 + fromEnum DiffFindFlagsFindAndBreakRewrites = 48 + fromEnum DiffFindFlagsFindForUntracked = 64 + fromEnum DiffFindFlagsFindAll = 255 + fromEnum DiffFindFlagsFindIgnoreLeadingWhitespace = 0 + fromEnum DiffFindFlagsFindIgnoreWhitespace = 4096 + fromEnum DiffFindFlagsFindDontIgnoreWhitespace = 8192 + fromEnum DiffFindFlagsFindExactMatchOnly = 16384 + fromEnum DiffFindFlagsBreakRewritesForRenamesOnly = 32768 + fromEnum DiffFindFlagsFindRemoveUnmodified = 65536 + fromEnum (AnotherDiffFindFlags k) = k + + toEnum 0 = DiffFindFlagsFindByConfig + toEnum 1 = DiffFindFlagsFindRenames + toEnum 2 = DiffFindFlagsFindRenamesFromRewrites + toEnum 4 = DiffFindFlagsFindCopies + toEnum 8 = DiffFindFlagsFindCopiesFromUnmodified + toEnum 16 = DiffFindFlagsFindRewrites + toEnum 32 = DiffFindFlagsBreakRewrites + toEnum 48 = DiffFindFlagsFindAndBreakRewrites + toEnum 64 = DiffFindFlagsFindForUntracked + toEnum 255 = DiffFindFlagsFindAll + toEnum 0 = DiffFindFlagsFindIgnoreLeadingWhitespace + toEnum 4096 = DiffFindFlagsFindIgnoreWhitespace + toEnum 8192 = DiffFindFlagsFindDontIgnoreWhitespace + toEnum 16384 = DiffFindFlagsFindExactMatchOnly + toEnum 32768 = DiffFindFlagsBreakRewritesForRenamesOnly + toEnum 65536 = DiffFindFlagsFindRemoveUnmodified + toEnum k = AnotherDiffFindFlags k + +instance P.Ord DiffFindFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_diff_find_flags_get_type" c_ggit_diff_find_flags_get_type :: + IO GType + +instance BoxedFlags DiffFindFlags where + boxedFlagsType _ = c_ggit_diff_find_flags_get_type + +instance IsGFlag DiffFindFlags + +-- Flags Credtype +{- | +/No description available in the introspection data./ +-} +data Credtype = + CredtypeUserpassPlaintext + {- ^ + /No description available in the introspection data./ + -} + | CredtypeSshKey + {- ^ + /No description available in the introspection data./ + -} + | CredtypeSshCustom + {- ^ + /No description available in the introspection data./ + -} + | CredtypeDefault + {- ^ + /No description available in the introspection data./ + -} + | CredtypeSshInteractive + {- ^ + /No description available in the introspection data./ + -} + | AnotherCredtype Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum Credtype where + fromEnum CredtypeUserpassPlaintext = 1 + fromEnum CredtypeSshKey = 2 + fromEnum CredtypeSshCustom = 4 + fromEnum CredtypeDefault = 8 + fromEnum CredtypeSshInteractive = 16 + fromEnum (AnotherCredtype k) = k + + toEnum 1 = CredtypeUserpassPlaintext + toEnum 2 = CredtypeSshKey + toEnum 4 = CredtypeSshCustom + toEnum 8 = CredtypeDefault + toEnum 16 = CredtypeSshInteractive + toEnum k = AnotherCredtype k + +instance P.Ord Credtype where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_credtype_get_type" c_ggit_credtype_get_type :: + IO GType + +instance BoxedFlags Credtype where + boxedFlagsType _ = c_ggit_credtype_get_type + +instance IsGFlag Credtype + +-- Flags CreateFlags +{- | +Describes how something should be created. +-} +data CreateFlags = + CreateFlagsNone + {- ^ + attempt to create. + -} + | CreateFlagsForce + {- ^ + force creation. + -} + | AnotherCreateFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CreateFlags where + fromEnum CreateFlagsNone = 0 + fromEnum CreateFlagsForce = 1 + fromEnum (AnotherCreateFlags k) = k + + toEnum 0 = CreateFlagsNone + toEnum 1 = CreateFlagsForce + toEnum k = AnotherCreateFlags k + +instance P.Ord CreateFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_create_flags_get_type" c_ggit_create_flags_get_type :: + IO GType + +instance BoxedFlags CreateFlags where + boxedFlagsType _ = c_ggit_create_flags_get_type + +instance IsGFlag CreateFlags + +-- Flags CheckoutStrategy +{- | +/No description available in the introspection data./ +-} +data CheckoutStrategy = + CheckoutStrategyNone + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategySafe + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyForce + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyRecreateMissing + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyAllowConflicts + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyRemoveUntracked + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyRemoveIgnored + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyUpdateOnly + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyDontUpdateIndex + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyNoRefresh + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategySkipUnmerged + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyUseOurs + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyUseTheirs + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyDisablePathspecMatch + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategySkipLockedDirectories + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyDontOverwriteIgnored + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyConflictStyleMerge + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyConflictStyleDiff3 + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyDontRemoveExisting + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyDontWriteIndex + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyUpdateSubmodules + {- ^ + /No description available in the introspection data./ + -} + | CheckoutStrategyUpdateSubmodulesIfChanged + {- ^ + /No description available in the introspection data./ + -} + | AnotherCheckoutStrategy Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CheckoutStrategy where + fromEnum CheckoutStrategyNone = 0 + fromEnum CheckoutStrategySafe = 1 + fromEnum CheckoutStrategyForce = 2 + fromEnum CheckoutStrategyRecreateMissing = 4 + fromEnum CheckoutStrategyAllowConflicts = 16 + fromEnum CheckoutStrategyRemoveUntracked = 32 + fromEnum CheckoutStrategyRemoveIgnored = 64 + fromEnum CheckoutStrategyUpdateOnly = 128 + fromEnum CheckoutStrategyDontUpdateIndex = 256 + fromEnum CheckoutStrategyNoRefresh = 512 + fromEnum CheckoutStrategySkipUnmerged = 1024 + fromEnum CheckoutStrategyUseOurs = 2048 + fromEnum CheckoutStrategyUseTheirs = 4096 + fromEnum CheckoutStrategyDisablePathspecMatch = 8192 + fromEnum CheckoutStrategySkipLockedDirectories = 262144 + fromEnum CheckoutStrategyDontOverwriteIgnored = 524288 + fromEnum CheckoutStrategyConflictStyleMerge = 1048576 + fromEnum CheckoutStrategyConflictStyleDiff3 = 2097152 + fromEnum CheckoutStrategyDontRemoveExisting = 4194304 + fromEnum CheckoutStrategyDontWriteIndex = 8388608 + fromEnum CheckoutStrategyUpdateSubmodules = 65536 + fromEnum CheckoutStrategyUpdateSubmodulesIfChanged = 131072 + fromEnum (AnotherCheckoutStrategy k) = k + + toEnum 0 = CheckoutStrategyNone + toEnum 1 = CheckoutStrategySafe + toEnum 2 = CheckoutStrategyForce + toEnum 4 = CheckoutStrategyRecreateMissing + toEnum 16 = CheckoutStrategyAllowConflicts + toEnum 32 = CheckoutStrategyRemoveUntracked + toEnum 64 = CheckoutStrategyRemoveIgnored + toEnum 128 = CheckoutStrategyUpdateOnly + toEnum 256 = CheckoutStrategyDontUpdateIndex + toEnum 512 = CheckoutStrategyNoRefresh + toEnum 1024 = CheckoutStrategySkipUnmerged + toEnum 2048 = CheckoutStrategyUseOurs + toEnum 4096 = CheckoutStrategyUseTheirs + toEnum 8192 = CheckoutStrategyDisablePathspecMatch + toEnum 262144 = CheckoutStrategySkipLockedDirectories + toEnum 524288 = CheckoutStrategyDontOverwriteIgnored + toEnum 1048576 = CheckoutStrategyConflictStyleMerge + toEnum 2097152 = CheckoutStrategyConflictStyleDiff3 + toEnum 4194304 = CheckoutStrategyDontRemoveExisting + toEnum 8388608 = CheckoutStrategyDontWriteIndex + toEnum 65536 = CheckoutStrategyUpdateSubmodules + toEnum 131072 = CheckoutStrategyUpdateSubmodulesIfChanged + toEnum k = AnotherCheckoutStrategy k + +instance P.Ord CheckoutStrategy where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_checkout_strategy_get_type" c_ggit_checkout_strategy_get_type :: + IO GType + +instance BoxedFlags CheckoutStrategy where + boxedFlagsType _ = c_ggit_checkout_strategy_get_type + +instance IsGFlag CheckoutStrategy + +-- Flags CheckoutNotifyFlags +{- | +/No description available in the introspection data./ +-} +data CheckoutNotifyFlags = + CheckoutNotifyFlagsNone + {- ^ + /No description available in the introspection data./ + -} + | CheckoutNotifyFlagsConflict + {- ^ + /No description available in the introspection data./ + -} + | CheckoutNotifyFlagsDirty + {- ^ + /No description available in the introspection data./ + -} + | CheckoutNotifyFlagsUpdated + {- ^ + /No description available in the introspection data./ + -} + | CheckoutNotifyFlagsUntracked + {- ^ + /No description available in the introspection data./ + -} + | CheckoutNotifyFlagsIgnored + {- ^ + /No description available in the introspection data./ + -} + | CheckoutNotifyFlagsAll + {- ^ + /No description available in the introspection data./ + -} + | AnotherCheckoutNotifyFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CheckoutNotifyFlags where + fromEnum CheckoutNotifyFlagsNone = 0 + fromEnum CheckoutNotifyFlagsConflict = 1 + fromEnum CheckoutNotifyFlagsDirty = 2 + fromEnum CheckoutNotifyFlagsUpdated = 4 + fromEnum CheckoutNotifyFlagsUntracked = 8 + fromEnum CheckoutNotifyFlagsIgnored = 16 + fromEnum CheckoutNotifyFlagsAll = 65535 + fromEnum (AnotherCheckoutNotifyFlags k) = k + + toEnum 0 = CheckoutNotifyFlagsNone + toEnum 1 = CheckoutNotifyFlagsConflict + toEnum 2 = CheckoutNotifyFlagsDirty + toEnum 4 = CheckoutNotifyFlagsUpdated + toEnum 8 = CheckoutNotifyFlagsUntracked + toEnum 16 = CheckoutNotifyFlagsIgnored + toEnum 65535 = CheckoutNotifyFlagsAll + toEnum k = AnotherCheckoutNotifyFlags k + +instance P.Ord CheckoutNotifyFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_checkout_notify_flags_get_type" c_ggit_checkout_notify_flags_get_type :: + IO GType + +instance BoxedFlags CheckoutNotifyFlags where + boxedFlagsType _ = c_ggit_checkout_notify_flags_get_type + +instance IsGFlag CheckoutNotifyFlags + +-- Flags BlameFlags +{- | +/No description available in the introspection data./ +-} +data BlameFlags = + BlameFlagsNormal + {- ^ + Normal blame, the default. + -} + | BlameFlagsTrackCopiesSameFile + {- ^ + Track lines that have moved within a file + (like git blame -M) + -} + | AnotherBlameFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum BlameFlags where + fromEnum BlameFlagsNormal = 0 + fromEnum BlameFlagsTrackCopiesSameFile = 1 + fromEnum (AnotherBlameFlags k) = k + + toEnum 0 = BlameFlagsNormal + toEnum 1 = BlameFlagsTrackCopiesSameFile + toEnum k = AnotherBlameFlags k + +instance P.Ord BlameFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_blame_flags_get_type" c_ggit_blame_flags_get_type :: + IO GType + +instance BoxedFlags BlameFlags where + boxedFlagsType _ = c_ggit_blame_flags_get_type + +instance IsGFlag BlameFlags + +-- Flags AttributeCheckFlags +{- | +Attribute check flags indicate the order in which to check for gitattributes. +git core uses /@gGITATTRIBUTECHECKFILETHENINDEX@/ for all operations, +except on checkout, where it uses /@gGITATTRIBUTECHECKINDEXTHENFILE@/. +-} +data AttributeCheckFlags = + AttributeCheckFlagsFileThenIndex + {- ^ + check working directory, then index. + -} + | AttributeCheckFlagsIndexThenFile + {- ^ + check index, then working directory. + -} + | AttributeCheckFlagsIndexOnly + {- ^ + check only index. + -} + | AttributeCheckFlagsNoSystem + {- ^ + ignore system wide attributes. + -} + | AnotherAttributeCheckFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum AttributeCheckFlags where + fromEnum AttributeCheckFlagsFileThenIndex = 0 + fromEnum AttributeCheckFlagsIndexThenFile = 1 + fromEnum AttributeCheckFlagsIndexOnly = 2 + fromEnum AttributeCheckFlagsNoSystem = 4 + fromEnum (AnotherAttributeCheckFlags k) = k + + toEnum 0 = AttributeCheckFlagsFileThenIndex + toEnum 1 = AttributeCheckFlagsIndexThenFile + toEnum 2 = AttributeCheckFlagsIndexOnly + toEnum 4 = AttributeCheckFlagsNoSystem + toEnum k = AnotherAttributeCheckFlags k + +instance P.Ord AttributeCheckFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "ggit_attribute_check_flags_get_type" c_ggit_attribute_check_flags_get_type :: + IO GType + +instance BoxedFlags AttributeCheckFlags where + boxedFlagsType _ = c_ggit_attribute_check_flags_get_type + +instance IsGFlag AttributeCheckFlags + + diff --git a/GI/Ggit/Flags.hs-boot b/GI/Ggit/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Flags.hs-boot @@ -0,0 +1,96 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Flags 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 + +data SubmoduleStatus +instance P.Enum SubmoduleStatus where +instance BoxedFlags SubmoduleStatus where +instance IsGFlag SubmoduleStatus +data StatusOption +instance P.Enum StatusOption where +instance BoxedFlags StatusOption where +instance IsGFlag StatusOption +data StatusFlags +instance P.Enum StatusFlags where +instance BoxedFlags StatusFlags where +instance IsGFlag StatusFlags +data StashFlags +instance P.Enum StashFlags where +instance BoxedFlags StashFlags where +instance IsGFlag StashFlags +data SortMode +instance P.Enum SortMode where +instance BoxedFlags SortMode where +instance IsGFlag SortMode +data MergeFlags +instance P.Enum MergeFlags where +instance BoxedFlags MergeFlags where +instance IsGFlag MergeFlags +data MergeFileFlags +instance P.Enum MergeFileFlags where +instance BoxedFlags MergeFileFlags where +instance IsGFlag MergeFileFlags +data FeatureFlags +instance P.Enum FeatureFlags where +instance BoxedFlags FeatureFlags where +instance IsGFlag FeatureFlags +data DiffOption +instance P.Enum DiffOption where +instance BoxedFlags DiffOption where +instance IsGFlag DiffOption +data DiffFormatEmailFlags +instance P.Enum DiffFormatEmailFlags where +instance BoxedFlags DiffFormatEmailFlags where +instance IsGFlag DiffFormatEmailFlags +data DiffFlag +instance P.Enum DiffFlag where +instance BoxedFlags DiffFlag where +instance IsGFlag DiffFlag +data DiffFindFlags +instance P.Enum DiffFindFlags where +instance BoxedFlags DiffFindFlags where +instance IsGFlag DiffFindFlags +data Credtype +instance P.Enum Credtype where +instance BoxedFlags Credtype where +instance IsGFlag Credtype +data CreateFlags +instance P.Enum CreateFlags where +instance BoxedFlags CreateFlags where +instance IsGFlag CreateFlags +data CheckoutStrategy +instance P.Enum CheckoutStrategy where +instance BoxedFlags CheckoutStrategy where +instance IsGFlag CheckoutStrategy +data CheckoutNotifyFlags +instance P.Enum CheckoutNotifyFlags where +instance BoxedFlags CheckoutNotifyFlags where +instance IsGFlag CheckoutNotifyFlags +data BlameFlags +instance P.Enum BlameFlags where +instance BoxedFlags BlameFlags where +instance IsGFlag BlameFlags +data AttributeCheckFlags +instance P.Enum AttributeCheckFlags where +instance BoxedFlags AttributeCheckFlags where +instance IsGFlag AttributeCheckFlags diff --git a/GI/Ggit/Functions.hs b/GI/Ggit/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Functions.hs @@ -0,0 +1,140 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Functions + ( + + -- * Methods +-- ** getFeatures #method:getFeatures# + + getFeatures , + + +-- ** init #method:init# + + init , + + +-- ** messagePrettify #method:messagePrettify# + + messagePrettify , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags + +-- function ggit_message_prettify +-- Args : [Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "strip_comments", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to strip comments.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "comment_char", argType = TBasicType TInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "comment character.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_message_prettify" ggit_message_prettify :: + CString -> -- message : TBasicType TUTF8 + CInt -> -- strip_comments : TBasicType TBoolean + Int8 -> -- comment_char : TBasicType TInt8 + IO CString + +{- | +Prettify a commit message by removing excess whitespace and making sure the +last line ends with a newline. If /@stripComments@/ is 'True', then lines +starting with a /@commentChar@/ will be removed. +-} +messagePrettify :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@message@/: the message. -} + -> Bool + {- ^ /@stripComments@/: whether to strip comments. -} + -> Int8 + {- ^ /@commentChar@/: comment character. -} + -> m T.Text + {- ^ __Returns:__ the prettified message. -} +messagePrettify message stripComments commentChar = liftIO $ do + message' <- textToCString message + let stripComments' = (fromIntegral . fromEnum) stripComments + result <- ggit_message_prettify message' stripComments' commentChar + checkUnexpectedReturnNULL "messagePrettify" result + result' <- cstringToText result + freeMem result + freeMem message' + return result' + + +-- function ggit_init +-- Args : [] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_init" ggit_init :: + IO () + +{- | +Call this function before using any other libgit2-glib function. +-} +init :: + (B.CallStack.HasCallStack, MonadIO m) => + m () +init = liftIO $ do + ggit_init + return () + + +-- function ggit_get_features +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "FeatureFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_get_features" ggit_get_features :: + IO CUInt + +{- | +Gets the features of the library. +-} +getFeatures :: + (B.CallStack.HasCallStack, MonadIO m) => + m [Ggit.Flags.FeatureFlags] + {- ^ __Returns:__ a 'GI.Ggit.Flags.FeatureFlags'. -} +getFeatures = liftIO $ do + result <- ggit_get_features + let result' = wordToGFlags result + return result' + + + diff --git a/GI/Ggit/Objects.hs b/GI/Ggit/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects.hs @@ -0,0 +1,109 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects + ( module GI.Ggit.Objects.Blame , + module GI.Ggit.Objects.Blob , + module GI.Ggit.Objects.BlobOutputStream , + module GI.Ggit.Objects.Branch , + module GI.Ggit.Objects.CheckoutOptions , + module GI.Ggit.Objects.CherryPickOptions, + module GI.Ggit.Objects.CloneOptions , + module GI.Ggit.Objects.Commit , + module GI.Ggit.Objects.CommitParents , + module GI.Ggit.Objects.Config , + module GI.Ggit.Objects.Cred , + module GI.Ggit.Objects.CredPlaintext , + module GI.Ggit.Objects.CredSshInteractive, + module GI.Ggit.Objects.CredSshKeyFromAgent, + module GI.Ggit.Objects.Diff , + module GI.Ggit.Objects.DiffFindOptions , + module GI.Ggit.Objects.DiffFormatEmailOptions, + module GI.Ggit.Objects.DiffOptions , + module GI.Ggit.Objects.Index , + module GI.Ggit.Objects.Native , + module GI.Ggit.Objects.Object , + module GI.Ggit.Objects.ObjectFactoryBase, + module GI.Ggit.Objects.ProxyOptions , + module GI.Ggit.Objects.PushOptions , + module GI.Ggit.Objects.Rebase , + module GI.Ggit.Objects.Ref , + module GI.Ggit.Objects.Remote , + module GI.Ggit.Objects.RemoteCallbacks , + module GI.Ggit.Objects.Repository , + module GI.Ggit.Objects.RevisionWalker , + module GI.Ggit.Objects.Signature , + module GI.Ggit.Objects.SubmoduleUpdateOptions, + module GI.Ggit.Objects.Tag , + module GI.Ggit.Objects.Tree , + module GI.Ggit.Objects.TreeBuilder , + + + ) where + +import GI.Ggit.Objects.Blame +import GI.Ggit.Objects.Blob +import GI.Ggit.Objects.BlobOutputStream +import GI.Ggit.Objects.Branch +import GI.Ggit.Objects.CheckoutOptions +import GI.Ggit.Objects.CherryPickOptions +import GI.Ggit.Objects.CloneOptions +import GI.Ggit.Objects.Commit +import GI.Ggit.Objects.CommitParents +import GI.Ggit.Objects.Config +import GI.Ggit.Objects.Cred +import GI.Ggit.Objects.CredPlaintext +import GI.Ggit.Objects.CredSshInteractive +import GI.Ggit.Objects.CredSshKeyFromAgent +import GI.Ggit.Objects.Diff +import GI.Ggit.Objects.DiffFindOptions +import GI.Ggit.Objects.DiffFormatEmailOptions +import GI.Ggit.Objects.DiffOptions +import GI.Ggit.Objects.Index +import GI.Ggit.Objects.Native +import GI.Ggit.Objects.Object +import GI.Ggit.Objects.ObjectFactoryBase +import GI.Ggit.Objects.ProxyOptions +import GI.Ggit.Objects.PushOptions +import GI.Ggit.Objects.Rebase +import GI.Ggit.Objects.Ref +import GI.Ggit.Objects.Remote +import GI.Ggit.Objects.RemoteCallbacks +import GI.Ggit.Objects.Repository +import GI.Ggit.Objects.RevisionWalker +import GI.Ggit.Objects.Signature +import GI.Ggit.Objects.SubmoduleUpdateOptions +import GI.Ggit.Objects.Tag +import GI.Ggit.Objects.Tree +import GI.Ggit.Objects.TreeBuilder + +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 + + + diff --git a/GI/Ggit/Objects/Blame.hs b/GI/Ggit/Objects/Blame.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Blame.hs @@ -0,0 +1,398 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a blame. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Blame + ( + +-- * Exported types + Blame(..) , + IsBlame , + toBlame , + noBlame , + + + -- * Methods +-- ** fromBuffer #method:fromBuffer# + +#if ENABLE_OVERLOADING + BlameFromBufferMethodInfo , +#endif + blameFromBuffer , + + +-- ** getFlags #method:getFlags# + + blameGetFlags , + + +-- ** getHunkByIndex #method:getHunkByIndex# + +#if ENABLE_OVERLOADING + BlameGetHunkByIndexMethodInfo , +#endif + blameGetHunkByIndex , + + +-- ** getHunkByLine #method:getHunkByLine# + +#if ENABLE_OVERLOADING + BlameGetHunkByLineMethodInfo , +#endif + blameGetHunkByLine , + + +-- ** getHunkCount #method:getHunkCount# + +#if ENABLE_OVERLOADING + BlameGetHunkCountMethodInfo , +#endif + blameGetHunkCount , + + +-- ** setFlags #method:setFlags# + + 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 + +-- | Memory-managed wrapper type. +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 + + +-- | Type class for types which can be safely cast to `Blame`, for instance with `toBlame`. +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] + +-- | Cast to `Blame`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toBlame :: (MonadIO m, IsBlame o) => o -> m Blame +toBlame = liftIO . unsafeCastTo Blame + +-- | A convenience alias for `Nothing` :: `Maybe` `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 "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 + +-- method Blame::from_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame", argType = TInterface (Name {namespace = "Ggit", name = "Blame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlame.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the contents of the file.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer_length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "buffer_length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Blame"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_blame_from_buffer" ggit_blame_from_buffer :: + Ptr Blame -> -- blame : TInterface (Name {namespace = "Ggit", name = "Blame"}) + Ptr Word8 -> -- buffer : TCArray False (-1) 2 (TBasicType TUInt8) + Word64 -> -- buffer_length : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO (Ptr Blame) + +{- | +Get blame data for a file that has been modified in memory. /@blame@/ is a +pre-calculated blame for the in-odb history of the file. This means that once +a file blame is completed (which can be expensitve), updating the buffer +blame is very fast. + +Lines that differ between the buffer and the committed version are marked as +having a zero id for their @/ggit_blame_hunk_get_final_commit_id/@. +-} +blameFromBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsBlame a) => + a + {- ^ /@blame@/: a 'GI.Ggit.Objects.Blame.Blame'. -} + -> ByteString + {- ^ /@buffer@/: the contents of the file. -} + -> m (Maybe Blame) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Blame.Blame' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +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 + +-- method Blame::get_hunk_by_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame", argType = TInterface (Name {namespace = "Ggit", name = "Blame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlameHunk"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_get_hunk_by_index" ggit_blame_get_hunk_by_index :: + Ptr Blame -> -- blame : TInterface (Name {namespace = "Ggit", name = "Blame"}) + Word32 -> -- idx : TBasicType TUInt32 + IO (Ptr Ggit.BlameHunk.BlameHunk) + +{- | +/No description available in the introspection data./ +-} +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 + +-- method Blame::get_hunk_by_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame", argType = TInterface (Name {namespace = "Ggit", name = "Blame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlameHunk"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_get_hunk_by_line" ggit_blame_get_hunk_by_line :: + Ptr Blame -> -- blame : TInterface (Name {namespace = "Ggit", name = "Blame"}) + Word32 -> -- line : TBasicType TUInt32 + IO (Ptr Ggit.BlameHunk.BlameHunk) + +{- | +/No description available in the introspection data./ +-} +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 + +-- method Blame::get_hunk_count +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame", argType = TInterface (Name {namespace = "Ggit", name = "Blame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_get_hunk_count" ggit_blame_get_hunk_count :: + Ptr Blame -> -- blame : TInterface (Name {namespace = "Ggit", name = "Blame"}) + IO Word32 + +{- | +/No description available in the introspection data./ +-} +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 + +-- method Blame::get_flags +-- method type : MemberFunction +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlameFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_get_flags" ggit_blame_get_flags :: + Ptr Ggit.BlameOptions.BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO CUInt + +{- | +Get the blame options flags. +-} +blameGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + Ggit.BlameOptions.BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m [Ggit.Flags.BlameFlags] + {- ^ __Returns:__ a 'GI.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 + +-- method Blame::set_flags +-- method type : MemberFunction +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "BlameFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_set_flags" ggit_blame_set_flags :: + Ptr Ggit.BlameOptions.BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "BlameFlags"}) + IO () + +{- | +Set the blame options flags. +-} +blameSetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + Ggit.BlameOptions.BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> [Ggit.Flags.BlameFlags] + {- ^ /@flags@/: a 'GI.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 + + diff --git a/GI/Ggit/Objects/Blame.hs-boot b/GI/Ggit/Objects/Blame.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Blame.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Blame 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 + +newtype Blame = Blame (ManagedPtr Blame) +instance GObject Blame where +class (GObject o, O.IsDescendantOf Blame o) => IsBlame o +instance (GObject o, O.IsDescendantOf Blame o) => IsBlame o +instance O.HasParentTypes Blame +#if ENABLE_OVERLOADING +data BlameFromBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameGetHunkByIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameGetHunkByLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameGetHunkCountMethodInfo +#endif diff --git a/GI/Ggit/Objects/Blob.hs b/GI/Ggit/Objects/Blob.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Blob.hs @@ -0,0 +1,229 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a blob object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Blob + ( + +-- * Exported types + Blob(..) , + IsBlob , + toBlob , + noBlob , + + + -- * Methods +-- ** getRawContent #method:getRawContent# + +#if ENABLE_OVERLOADING + BlobGetRawContentMethodInfo , +#endif + blobGetRawContent , + + +-- ** isBinary #method:isBinary# + +#if ENABLE_OVERLOADING + BlobIsBinaryMethodInfo , +#endif + blobIsBinary , + + + + + ) 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.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase + +-- | Memory-managed wrapper type. +newtype Blob = Blob (ManagedPtr Blob) +foreign import ccall "ggit_blob_get_type" + c_ggit_blob_get_type :: IO GType + +instance GObject Blob where + gobjectType = c_ggit_blob_get_type + + +-- | Type class for types which can be safely cast to `Blob`, for instance with `toBlob`. +class (GObject o, O.IsDescendantOf Blob o) => IsBlob o +instance (GObject o, O.IsDescendantOf Blob o) => IsBlob o + +instance O.HasParentTypes Blob +type instance O.ParentTypes Blob = '[Ggit.Object.Object, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Blob`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toBlob :: (MonadIO m, IsBlob o) => o -> m Blob +toBlob = liftIO . unsafeCastTo Blob + +-- | A convenience alias for `Nothing` :: `Maybe` `Blob`. +noBlob :: Maybe Blob +noBlob = Nothing + +#if ENABLE_OVERLOADING +type family ResolveBlobMethod (t :: Symbol) (o :: *) :: * where + ResolveBlobMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveBlobMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveBlobMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveBlobMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveBlobMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveBlobMethod "isBinary" o = BlobIsBinaryMethodInfo + ResolveBlobMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveBlobMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveBlobMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveBlobMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveBlobMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveBlobMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveBlobMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveBlobMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveBlobMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveBlobMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveBlobMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveBlobMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveBlobMethod "getId" o = Ggit.Object.ObjectGetIdMethodInfo + ResolveBlobMethod "getOwner" o = Ggit.Object.ObjectGetOwnerMethodInfo + ResolveBlobMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveBlobMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveBlobMethod "getRawContent" o = BlobGetRawContentMethodInfo + ResolveBlobMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveBlobMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveBlobMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBlobMethod t Blob, O.MethodInfo info Blob p) => OL.IsLabel t (Blob -> 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 Blob +type instance O.AttributeList Blob = BlobAttributeList +type BlobAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Blob = BlobSignalList +type BlobSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Blob::get_raw_content +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blob", argType = TInterface (Name {namespace = "Ggit", name = "Blob"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value of the length of the data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value of the length of the data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (TCArray False (-1) 1 (TBasicType TUInt8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blob_get_raw_content" ggit_blob_get_raw_content :: + Ptr Blob -> -- blob : TInterface (Name {namespace = "Ggit", name = "Blob"}) + Ptr Word64 -> -- length : TBasicType TUInt64 + IO (Ptr Word8) + +{- | +Gets a read-only buffer with the raw contents of /@blob@/. + +A pointer to the raw contents of /@blob@/ is returned. +This pointer is owned internally by /@object@/ and must +not be free\'d. The pointer may be invalidated at a later +time. +-} +blobGetRawContent :: + (B.CallStack.HasCallStack, MonadIO m, IsBlob a) => + a + {- ^ /@blob@/: a 'GI.Ggit.Objects.Blob.Blob'. -} + -> m (Maybe ByteString) + {- ^ __Returns:__ the blob content or + 'Nothing' if the blob does not have any content. -} +blobGetRawContent blob = liftIO $ do + blob' <- unsafeManagedPtrCastPtr blob + length_ <- allocMem :: IO (Ptr Word64) + result <- ggit_blob_get_raw_content blob' length_ + length_' <- peek length_ + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (unpackByteStringWithLength length_') result' + return result'' + touchManagedPtr blob + freeMem length_ + return maybeResult + +#if ENABLE_OVERLOADING +data BlobGetRawContentMethodInfo +instance (signature ~ (m (Maybe ByteString)), MonadIO m, IsBlob a) => O.MethodInfo BlobGetRawContentMethodInfo a signature where + overloadedMethod _ = blobGetRawContent + +#endif + +-- method Blob::is_binary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blob", argType = TInterface (Name {namespace = "Ggit", name = "Blob"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blob_is_binary" ggit_blob_is_binary :: + Ptr Blob -> -- blob : TInterface (Name {namespace = "Ggit", name = "Blob"}) + IO CInt + +{- | +Check whether the blob is binary. +-} +blobIsBinary :: + (B.CallStack.HasCallStack, MonadIO m, IsBlob a) => + a + {- ^ /@blob@/: a 'GI.Ggit.Objects.Blob.Blob'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the blob is binary, 'False' otherwise. -} +blobIsBinary blob = liftIO $ do + blob' <- unsafeManagedPtrCastPtr blob + result <- ggit_blob_is_binary blob' + let result' = (/= 0) result + touchManagedPtr blob + return result' + +#if ENABLE_OVERLOADING +data BlobIsBinaryMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsBlob a) => O.MethodInfo BlobIsBinaryMethodInfo a signature where + overloadedMethod _ = blobIsBinary + +#endif + + diff --git a/GI/Ggit/Objects/Blob.hs-boot b/GI/Ggit/Objects/Blob.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Blob.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Blob 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 + +newtype Blob = Blob (ManagedPtr Blob) +instance GObject Blob where +class (GObject o, O.IsDescendantOf Blob o) => IsBlob o +instance (GObject o, O.IsDescendantOf Blob o) => IsBlob o +instance O.HasParentTypes Blob +#if ENABLE_OVERLOADING +data BlobGetRawContentMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlobIsBinaryMethodInfo +#endif diff --git a/GI/Ggit/Objects/BlobOutputStream.hs b/GI/Ggit/Objects/BlobOutputStream.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/BlobOutputStream.hs @@ -0,0 +1,253 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a blob stream object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.BlobOutputStream + ( + +-- * Exported types + BlobOutputStream(..) , + IsBlobOutputStream , + toBlobOutputStream , + noBlobOutputStream , + + + -- * Methods +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + BlobOutputStreamGetIdMethodInfo , +#endif + blobOutputStreamGetId , + + + + + -- * Properties +-- ** repository #attr:repository# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + BlobOutputStreamRepositoryPropertyInfo , +#endif +#if ENABLE_OVERLOADING + blobOutputStreamRepository , +#endif + constructBlobOutputStreamRepository , + + + + + ) 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.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream + +-- | Memory-managed wrapper type. +newtype BlobOutputStream = BlobOutputStream (ManagedPtr BlobOutputStream) +foreign import ccall "ggit_blob_output_stream_get_type" + c_ggit_blob_output_stream_get_type :: IO GType + +instance GObject BlobOutputStream where + gobjectType = c_ggit_blob_output_stream_get_type + + +-- | Type class for types which can be safely cast to `BlobOutputStream`, for instance with `toBlobOutputStream`. +class (GObject o, O.IsDescendantOf BlobOutputStream o) => IsBlobOutputStream o +instance (GObject o, O.IsDescendantOf BlobOutputStream o) => IsBlobOutputStream o + +instance O.HasParentTypes BlobOutputStream +type instance O.ParentTypes BlobOutputStream = '[Gio.OutputStream.OutputStream, GObject.Object.Object] + +-- | Cast to `BlobOutputStream`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toBlobOutputStream :: (MonadIO m, IsBlobOutputStream o) => o -> m BlobOutputStream +toBlobOutputStream = liftIO . unsafeCastTo BlobOutputStream + +-- | A convenience alias for `Nothing` :: `Maybe` `BlobOutputStream`. +noBlobOutputStream :: Maybe BlobOutputStream +noBlobOutputStream = Nothing + +#if ENABLE_OVERLOADING +type family ResolveBlobOutputStreamMethod (t :: Symbol) (o :: *) :: * where + ResolveBlobOutputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveBlobOutputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveBlobOutputStreamMethod "clearPending" o = Gio.OutputStream.OutputStreamClearPendingMethodInfo + ResolveBlobOutputStreamMethod "close" o = Gio.OutputStream.OutputStreamCloseMethodInfo + ResolveBlobOutputStreamMethod "closeAsync" o = Gio.OutputStream.OutputStreamCloseAsyncMethodInfo + ResolveBlobOutputStreamMethod "closeFinish" o = Gio.OutputStream.OutputStreamCloseFinishMethodInfo + ResolveBlobOutputStreamMethod "flush" o = Gio.OutputStream.OutputStreamFlushMethodInfo + ResolveBlobOutputStreamMethod "flushAsync" o = Gio.OutputStream.OutputStreamFlushAsyncMethodInfo + ResolveBlobOutputStreamMethod "flushFinish" o = Gio.OutputStream.OutputStreamFlushFinishMethodInfo + ResolveBlobOutputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveBlobOutputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveBlobOutputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveBlobOutputStreamMethod "hasPending" o = Gio.OutputStream.OutputStreamHasPendingMethodInfo + ResolveBlobOutputStreamMethod "isClosed" o = Gio.OutputStream.OutputStreamIsClosedMethodInfo + ResolveBlobOutputStreamMethod "isClosing" o = Gio.OutputStream.OutputStreamIsClosingMethodInfo + ResolveBlobOutputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveBlobOutputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveBlobOutputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveBlobOutputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveBlobOutputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveBlobOutputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveBlobOutputStreamMethod "splice" o = Gio.OutputStream.OutputStreamSpliceMethodInfo + ResolveBlobOutputStreamMethod "spliceAsync" o = Gio.OutputStream.OutputStreamSpliceAsyncMethodInfo + ResolveBlobOutputStreamMethod "spliceFinish" o = Gio.OutputStream.OutputStreamSpliceFinishMethodInfo + ResolveBlobOutputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveBlobOutputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveBlobOutputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveBlobOutputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveBlobOutputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveBlobOutputStreamMethod "write" o = Gio.OutputStream.OutputStreamWriteMethodInfo + ResolveBlobOutputStreamMethod "writeAll" o = Gio.OutputStream.OutputStreamWriteAllMethodInfo + ResolveBlobOutputStreamMethod "writeAllAsync" o = Gio.OutputStream.OutputStreamWriteAllAsyncMethodInfo + ResolveBlobOutputStreamMethod "writeAllFinish" o = Gio.OutputStream.OutputStreamWriteAllFinishMethodInfo + ResolveBlobOutputStreamMethod "writeAsync" o = Gio.OutputStream.OutputStreamWriteAsyncMethodInfo + ResolveBlobOutputStreamMethod "writeBytes" o = Gio.OutputStream.OutputStreamWriteBytesMethodInfo + ResolveBlobOutputStreamMethod "writeBytesAsync" o = Gio.OutputStream.OutputStreamWriteBytesAsyncMethodInfo + ResolveBlobOutputStreamMethod "writeBytesFinish" o = Gio.OutputStream.OutputStreamWriteBytesFinishMethodInfo + ResolveBlobOutputStreamMethod "writeFinish" o = Gio.OutputStream.OutputStreamWriteFinishMethodInfo + ResolveBlobOutputStreamMethod "writev" o = Gio.OutputStream.OutputStreamWritevMethodInfo + ResolveBlobOutputStreamMethod "writevAll" o = Gio.OutputStream.OutputStreamWritevAllMethodInfo + ResolveBlobOutputStreamMethod "writevAllAsync" o = Gio.OutputStream.OutputStreamWritevAllAsyncMethodInfo + ResolveBlobOutputStreamMethod "writevAllFinish" o = Gio.OutputStream.OutputStreamWritevAllFinishMethodInfo + ResolveBlobOutputStreamMethod "writevAsync" o = Gio.OutputStream.OutputStreamWritevAsyncMethodInfo + ResolveBlobOutputStreamMethod "writevFinish" o = Gio.OutputStream.OutputStreamWritevFinishMethodInfo + ResolveBlobOutputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveBlobOutputStreamMethod "getId" o = BlobOutputStreamGetIdMethodInfo + ResolveBlobOutputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveBlobOutputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveBlobOutputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveBlobOutputStreamMethod "setPending" o = Gio.OutputStream.OutputStreamSetPendingMethodInfo + ResolveBlobOutputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveBlobOutputStreamMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBlobOutputStreamMethod t BlobOutputStream, O.MethodInfo info BlobOutputStream p) => OL.IsLabel t (BlobOutputStream -> 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 + +-- VVV Prop "repository" + -- Type: TInterface (Name {namespace = "Ggit", name = "Repository"}) + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Construct a `GValueConstruct` with valid value for the “@repository@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBlobOutputStreamRepository :: (IsBlobOutputStream o, Ggit.Repository.IsRepository a) => a -> IO (GValueConstruct o) +constructBlobOutputStreamRepository val = B.Properties.constructObjectPropertyObject "repository" (Just val) + +#if ENABLE_OVERLOADING +data BlobOutputStreamRepositoryPropertyInfo +instance AttrInfo BlobOutputStreamRepositoryPropertyInfo where + type AttrAllowedOps BlobOutputStreamRepositoryPropertyInfo = '[ 'AttrConstruct, 'AttrClear] + type AttrSetTypeConstraint BlobOutputStreamRepositoryPropertyInfo = Ggit.Repository.IsRepository + type AttrBaseTypeConstraint BlobOutputStreamRepositoryPropertyInfo = IsBlobOutputStream + type AttrGetType BlobOutputStreamRepositoryPropertyInfo = () + type AttrLabel BlobOutputStreamRepositoryPropertyInfo = "repository" + type AttrOrigin BlobOutputStreamRepositoryPropertyInfo = BlobOutputStream + attrGet _ = undefined + attrSet _ = undefined + attrConstruct _ = constructBlobOutputStreamRepository + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BlobOutputStream +type instance O.AttributeList BlobOutputStream = BlobOutputStreamAttributeList +type BlobOutputStreamAttributeList = ('[ '("repository", BlobOutputStreamRepositoryPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +blobOutputStreamRepository :: AttrLabelProxy "repository" +blobOutputStreamRepository = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList BlobOutputStream = BlobOutputStreamSignalList +type BlobOutputStreamSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method BlobOutputStream::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Ggit", name = "BlobOutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlobOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_blob_output_stream_get_id" ggit_blob_output_stream_get_id :: + Ptr BlobOutputStream -> -- stream : TInterface (Name {namespace = "Ggit", name = "BlobOutputStream"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Get the id of the written blob. The blob id is only available after the +stream has been properly closed. If an error occurred while writing the blob, +the 'Nothing' is returned and /@error@/ is set accordingly. +-} +blobOutputStreamGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsBlobOutputStream a) => + a + {- ^ /@stream@/: a 'GI.Ggit.Objects.BlobOutputStream.BlobOutputStream'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +blobOutputStreamGetId stream = liftIO $ do + stream' <- unsafeManagedPtrCastPtr stream + onException (do + result <- propagateGError $ ggit_blob_output_stream_get_id stream' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr stream + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data BlobOutputStreamGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsBlobOutputStream a) => O.MethodInfo BlobOutputStreamGetIdMethodInfo a signature where + overloadedMethod _ = blobOutputStreamGetId + +#endif + + diff --git a/GI/Ggit/Objects/BlobOutputStream.hs-boot b/GI/Ggit/Objects/BlobOutputStream.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/BlobOutputStream.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.BlobOutputStream 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 + +newtype BlobOutputStream = BlobOutputStream (ManagedPtr BlobOutputStream) +instance GObject BlobOutputStream where +class (GObject o, O.IsDescendantOf BlobOutputStream o) => IsBlobOutputStream o +instance (GObject o, O.IsDescendantOf BlobOutputStream o) => IsBlobOutputStream o +instance O.HasParentTypes BlobOutputStream +#if ENABLE_OVERLOADING +data BlobOutputStreamRepositoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data BlobOutputStreamGetIdMethodInfo +#endif diff --git a/GI/Ggit/Objects/Branch.hs b/GI/Ggit/Objects/Branch.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Branch.hs @@ -0,0 +1,408 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a branch object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Branch + ( + +-- * Exported types + Branch(..) , + IsBranch , + toBranch , + noBranch , + + + -- * Methods +-- ** delete #method:delete# + +#if ENABLE_OVERLOADING + BranchDeleteMethodInfo , +#endif + branchDelete , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + BranchGetNameMethodInfo , +#endif + branchGetName , + + +-- ** getUpstream #method:getUpstream# + +#if ENABLE_OVERLOADING + BranchGetUpstreamMethodInfo , +#endif + branchGetUpstream , + + +-- ** isHead #method:isHead# + +#if ENABLE_OVERLOADING + BranchIsHeadMethodInfo , +#endif + branchIsHead , + + +-- ** move #method:move# + +#if ENABLE_OVERLOADING + BranchMoveMethodInfo , +#endif + branchMove , + + + + + ) 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.Objects.Ref as Ggit.Ref + +-- | Memory-managed wrapper type. +newtype Branch = Branch (ManagedPtr Branch) +foreign import ccall "ggit_branch_get_type" + c_ggit_branch_get_type :: IO GType + +instance GObject Branch where + gobjectType = c_ggit_branch_get_type + + +-- | Type class for types which can be safely cast to `Branch`, for instance with `toBranch`. +class (GObject o, O.IsDescendantOf Branch o) => IsBranch o +instance (GObject o, O.IsDescendantOf Branch o) => IsBranch o + +instance O.HasParentTypes Branch +type instance O.ParentTypes Branch = '[Ggit.Ref.Ref, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Branch`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toBranch :: (MonadIO m, IsBranch o) => o -> m Branch +toBranch = liftIO . unsafeCastTo Branch + +-- | A convenience alias for `Nothing` :: `Maybe` `Branch`. +noBranch :: Maybe Branch +noBranch = Nothing + +#if ENABLE_OVERLOADING +type family ResolveBranchMethod (t :: Symbol) (o :: *) :: * where + ResolveBranchMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveBranchMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveBranchMethod "delete" o = BranchDeleteMethodInfo + ResolveBranchMethod "deleteLog" o = Ggit.Ref.RefDeleteLogMethodInfo + ResolveBranchMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveBranchMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveBranchMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveBranchMethod "hasLog" o = Ggit.Ref.RefHasLogMethodInfo + ResolveBranchMethod "isBranch" o = Ggit.Ref.RefIsBranchMethodInfo + ResolveBranchMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveBranchMethod "isHead" o = BranchIsHeadMethodInfo + ResolveBranchMethod "isNote" o = Ggit.Ref.RefIsNoteMethodInfo + ResolveBranchMethod "isRemote" o = Ggit.Ref.RefIsRemoteMethodInfo + ResolveBranchMethod "isTag" o = Ggit.Ref.RefIsTagMethodInfo + ResolveBranchMethod "lookup" o = Ggit.Ref.RefLookupMethodInfo + ResolveBranchMethod "move" o = BranchMoveMethodInfo + ResolveBranchMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveBranchMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveBranchMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveBranchMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveBranchMethod "rename" o = Ggit.Ref.RefRenameMethodInfo + ResolveBranchMethod "resolve" o = Ggit.Ref.RefResolveMethodInfo + ResolveBranchMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveBranchMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveBranchMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveBranchMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveBranchMethod "toString" o = Ggit.Ref.RefToStringMethodInfo + ResolveBranchMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveBranchMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveBranchMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveBranchMethod "getLog" o = Ggit.Ref.RefGetLogMethodInfo + ResolveBranchMethod "getName" o = BranchGetNameMethodInfo + ResolveBranchMethod "getOwner" o = Ggit.Ref.RefGetOwnerMethodInfo + ResolveBranchMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveBranchMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveBranchMethod "getReferenceType" o = Ggit.Ref.RefGetReferenceTypeMethodInfo + ResolveBranchMethod "getShorthand" o = Ggit.Ref.RefGetShorthandMethodInfo + ResolveBranchMethod "getSymbolicTarget" o = Ggit.Ref.RefGetSymbolicTargetMethodInfo + ResolveBranchMethod "getTarget" o = Ggit.Ref.RefGetTargetMethodInfo + ResolveBranchMethod "getUpstream" o = BranchGetUpstreamMethodInfo + ResolveBranchMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveBranchMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveBranchMethod "setSymbolicTarget" o = Ggit.Ref.RefSetSymbolicTargetMethodInfo + ResolveBranchMethod "setTarget" o = Ggit.Ref.RefSetTargetMethodInfo + ResolveBranchMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBranchMethod t Branch, O.MethodInfo info Branch p) => OL.IsLabel t (Branch -> 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 Branch +type instance O.AttributeList Branch = BranchAttributeList +type BranchAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Branch = BranchSignalList +type BranchSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Branch::delete +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "branch", argType = TInterface (Name {namespace = "Ggit", name = "Branch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_branch_delete" ggit_branch_delete :: + Ptr Branch -> -- branch : TInterface (Name {namespace = "Ggit", name = "Branch"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Deletes an existing branch reference. + +If the branch is successfully deleted, this object is +not useful anymore and if should be freed with 'GI.GObject.Objects.Object.objectUnref'. +-} +branchDelete :: + (B.CallStack.HasCallStack, MonadIO m, IsBranch a) => + a + {- ^ /@branch@/: a 'GI.Ggit.Objects.Branch.Branch'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +branchDelete branch = liftIO $ do + branch' <- unsafeManagedPtrCastPtr branch + onException (do + propagateGError $ ggit_branch_delete branch' + touchManagedPtr branch + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data BranchDeleteMethodInfo +instance (signature ~ (m ()), MonadIO m, IsBranch a) => O.MethodInfo BranchDeleteMethodInfo a signature where + overloadedMethod _ = branchDelete + +#endif + +-- method Branch::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "branch", argType = TInterface (Name {namespace = "Ggit", name = "Branch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_branch_get_name" ggit_branch_get_name :: + Ptr Branch -> -- branch : TInterface (Name {namespace = "Ggit", name = "Branch"}) + Ptr (Ptr GError) -> -- error + IO CString + +{- | +Gets the name of the given local or remote branch. +-} +branchGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsBranch a) => + a + {- ^ /@branch@/: a 'GI.Ggit.Objects.Branch.Branch'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of the given local or remote branch or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +branchGetName branch = liftIO $ do + branch' <- unsafeManagedPtrCastPtr branch + onException (do + result <- propagateGError $ ggit_branch_get_name branch' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr branch + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data BranchGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBranch a) => O.MethodInfo BranchGetNameMethodInfo a signature where + overloadedMethod _ = branchGetName + +#endif + +-- method Branch::get_upstream +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "branch", argType = TInterface (Name {namespace = "Ggit", name = "Branch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_branch_get_upstream" ggit_branch_get_upstream :: + Ptr Branch -> -- branch : TInterface (Name {namespace = "Ggit", name = "Branch"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Ref.Ref) + +{- | +Gets the reference supporting the remote tracking branch, +given a local branch reference. +-} +branchGetUpstream :: + (B.CallStack.HasCallStack, MonadIO m, IsBranch a) => + a + {- ^ /@branch@/: a 'GI.Ggit.Objects.Branch.Branch'. -} + -> m (Maybe Ggit.Ref.Ref) + {- ^ __Returns:__ the reference supporting the remote tracking branch or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +branchGetUpstream branch = liftIO $ do + branch' <- unsafeManagedPtrCastPtr branch + onException (do + result <- propagateGError $ ggit_branch_get_upstream branch' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Ref.Ref) result' + return result'' + touchManagedPtr branch + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data BranchGetUpstreamMethodInfo +instance (signature ~ (m (Maybe Ggit.Ref.Ref)), MonadIO m, IsBranch a) => O.MethodInfo BranchGetUpstreamMethodInfo a signature where + overloadedMethod _ = branchGetUpstream + +#endif + +-- method Branch::is_head +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "branch", argType = TInterface (Name {namespace = "Ggit", name = "Branch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_branch_is_head" ggit_branch_is_head :: + Ptr Branch -> -- branch : TInterface (Name {namespace = "Ggit", name = "Branch"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Determines if the current local branch is pointed at by HEAD. +-} +branchIsHead :: + (B.CallStack.HasCallStack, MonadIO m, IsBranch a) => + a + {- ^ /@branch@/: a 'GI.Ggit.Objects.Branch.Branch'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +branchIsHead branch = liftIO $ do + branch' <- unsafeManagedPtrCastPtr branch + onException (do + _ <- propagateGError $ ggit_branch_is_head branch' + touchManagedPtr branch + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data BranchIsHeadMethodInfo +instance (signature ~ (m ()), MonadIO m, IsBranch a) => O.MethodInfo BranchIsHeadMethodInfo a signature where + overloadedMethod _ = branchIsHead + +#endif + +-- method Branch::move +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "branch", argType = TInterface (Name {namespace = "Ggit", name = "Branch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_branch_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "target name of the branch once the move is performed; this name is validated for consistency.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "CreateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCreateFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Branch"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_branch_move" ggit_branch_move :: + Ptr Branch -> -- branch : TInterface (Name {namespace = "Ggit", name = "Branch"}) + CString -> -- new_branch_name : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "CreateFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Branch) + +{- | +Moves\/renames an existing branch reference. +-} +branchMove :: + (B.CallStack.HasCallStack, MonadIO m, IsBranch a) => + a + {- ^ /@branch@/: a 'GI.Ggit.Objects.Branch.Branch'. -} + -> T.Text + {- ^ /@newBranchName@/: target name of the branch once the move is performed; this name is validated for consistency. -} + -> [Ggit.Flags.CreateFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.CreateFlags'. -} + -> m (Maybe Branch) + {- ^ __Returns:__ the new branch or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +branchMove branch newBranchName flags = liftIO $ do + branch' <- unsafeManagedPtrCastPtr branch + newBranchName' <- textToCString newBranchName + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ ggit_branch_move branch' newBranchName' flags' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Branch) result' + return result'' + touchManagedPtr branch + freeMem newBranchName' + return maybeResult + ) (do + freeMem newBranchName' + ) + +#if ENABLE_OVERLOADING +data BranchMoveMethodInfo +instance (signature ~ (T.Text -> [Ggit.Flags.CreateFlags] -> m (Maybe Branch)), MonadIO m, IsBranch a) => O.MethodInfo BranchMoveMethodInfo a signature where + overloadedMethod _ = branchMove + +#endif + + diff --git a/GI/Ggit/Objects/Branch.hs-boot b/GI/Ggit/Objects/Branch.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Branch.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Branch 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 + +newtype Branch = Branch (ManagedPtr Branch) +instance GObject Branch where +class (GObject o, O.IsDescendantOf Branch o) => IsBranch o +instance (GObject o, O.IsDescendantOf Branch o) => IsBranch o +instance O.HasParentTypes Branch +#if ENABLE_OVERLOADING +data BranchDeleteMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchGetUpstreamMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchIsHeadMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchMoveMethodInfo +#endif diff --git a/GI/Ggit/Objects/CheckoutOptions.hs b/GI/Ggit/Objects/CheckoutOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CheckoutOptions.hs @@ -0,0 +1,2058 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when doign a checkout. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.CheckoutOptions + ( + +-- * Exported types + CheckoutOptions(..) , + IsCheckoutOptions , + toCheckoutOptions , + noCheckoutOptions , + + + -- * Methods +-- ** getAncestorLabel #method:getAncestorLabel# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetAncestorLabelMethodInfo, +#endif + checkoutOptionsGetAncestorLabel , + + +-- ** getBaseline #method:getBaseline# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetBaselineMethodInfo , +#endif + checkoutOptionsGetBaseline , + + +-- ** getDirMode #method:getDirMode# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetDirModeMethodInfo , +#endif + checkoutOptionsGetDirMode , + + +-- ** getDisableFilters #method:getDisableFilters# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetDisableFiltersMethodInfo, +#endif + checkoutOptionsGetDisableFilters , + + +-- ** getFileMode #method:getFileMode# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetFileModeMethodInfo , +#endif + checkoutOptionsGetFileMode , + + +-- ** getFileOpenFlags #method:getFileOpenFlags# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetFileOpenFlagsMethodInfo, +#endif + checkoutOptionsGetFileOpenFlags , + + +-- ** getNotifyFlags #method:getNotifyFlags# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetNotifyFlagsMethodInfo , +#endif + checkoutOptionsGetNotifyFlags , + + +-- ** getOurLabel #method:getOurLabel# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetOurLabelMethodInfo , +#endif + checkoutOptionsGetOurLabel , + + +-- ** getPaths #method:getPaths# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetPathsMethodInfo , +#endif + checkoutOptionsGetPaths , + + +-- ** getStrategy #method:getStrategy# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetStrategyMethodInfo , +#endif + checkoutOptionsGetStrategy , + + +-- ** getTargetDirectory #method:getTargetDirectory# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetTargetDirectoryMethodInfo, +#endif + checkoutOptionsGetTargetDirectory , + + +-- ** getTheirLabel #method:getTheirLabel# + +#if ENABLE_OVERLOADING + CheckoutOptionsGetTheirLabelMethodInfo , +#endif + checkoutOptionsGetTheirLabel , + + +-- ** new #method:new# + + checkoutOptionsNew , + + +-- ** setAncestorLabel #method:setAncestorLabel# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetAncestorLabelMethodInfo, +#endif + checkoutOptionsSetAncestorLabel , + + +-- ** setBaseline #method:setBaseline# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetBaselineMethodInfo , +#endif + checkoutOptionsSetBaseline , + + +-- ** setDirMode #method:setDirMode# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetDirModeMethodInfo , +#endif + checkoutOptionsSetDirMode , + + +-- ** setDisableFilters #method:setDisableFilters# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetDisableFiltersMethodInfo, +#endif + checkoutOptionsSetDisableFilters , + + +-- ** setFileMode #method:setFileMode# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetFileModeMethodInfo , +#endif + checkoutOptionsSetFileMode , + + +-- ** setFileOpenFlags #method:setFileOpenFlags# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetFileOpenFlagsMethodInfo, +#endif + checkoutOptionsSetFileOpenFlags , + + +-- ** setNotifyFlags #method:setNotifyFlags# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetNotifyFlagsMethodInfo , +#endif + checkoutOptionsSetNotifyFlags , + + +-- ** setOurLabel #method:setOurLabel# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetOurLabelMethodInfo , +#endif + checkoutOptionsSetOurLabel , + + +-- ** setPaths #method:setPaths# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetPathsMethodInfo , +#endif + checkoutOptionsSetPaths , + + +-- ** setStrategy #method:setStrategy# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetStrategyMethodInfo , +#endif + checkoutOptionsSetStrategy , + + +-- ** setTargetDirectory #method:setTargetDirectory# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetTargetDirectoryMethodInfo, +#endif + checkoutOptionsSetTargetDirectory , + + +-- ** setTheirLabel #method:setTheirLabel# + +#if ENABLE_OVERLOADING + CheckoutOptionsSetTheirLabelMethodInfo , +#endif + checkoutOptionsSetTheirLabel , + + + + + -- * Properties +-- ** ancestorLabel #attr:ancestorLabel# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsAncestorLabelPropertyInfo, +#endif +#if ENABLE_OVERLOADING + checkoutOptionsAncestorLabel , +#endif + clearCheckoutOptionsAncestorLabel , + constructCheckoutOptionsAncestorLabel , + getCheckoutOptionsAncestorLabel , + setCheckoutOptionsAncestorLabel , + + +-- ** baseline #attr:baseline# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsBaselinePropertyInfo , +#endif +#if ENABLE_OVERLOADING + checkoutOptionsBaseline , +#endif + clearCheckoutOptionsBaseline , + constructCheckoutOptionsBaseline , + getCheckoutOptionsBaseline , + setCheckoutOptionsBaseline , + + +-- ** dirMode #attr:dirMode# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsDirModePropertyInfo , +#endif +#if ENABLE_OVERLOADING + checkoutOptionsDirMode , +#endif + constructCheckoutOptionsDirMode , + getCheckoutOptionsDirMode , + setCheckoutOptionsDirMode , + + +-- ** disableFilters #attr:disableFilters# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsDisableFiltersPropertyInfo, +#endif +#if ENABLE_OVERLOADING + checkoutOptionsDisableFilters , +#endif + constructCheckoutOptionsDisableFilters , + getCheckoutOptionsDisableFilters , + setCheckoutOptionsDisableFilters , + + +-- ** fileMode #attr:fileMode# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsFileModePropertyInfo , +#endif +#if ENABLE_OVERLOADING + checkoutOptionsFileMode , +#endif + constructCheckoutOptionsFileMode , + getCheckoutOptionsFileMode , + setCheckoutOptionsFileMode , + + +-- ** fileOpenFlags #attr:fileOpenFlags# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsFileOpenFlagsPropertyInfo, +#endif +#if ENABLE_OVERLOADING + checkoutOptionsFileOpenFlags , +#endif + constructCheckoutOptionsFileOpenFlags , + getCheckoutOptionsFileOpenFlags , + setCheckoutOptionsFileOpenFlags , + + +-- ** notifyFlags #attr:notifyFlags# +{- | The checkout notify flags. +-} +#if ENABLE_OVERLOADING + CheckoutOptionsNotifyFlagsPropertyInfo , +#endif +#if ENABLE_OVERLOADING + checkoutOptionsNotifyFlags , +#endif + constructCheckoutOptionsNotifyFlags , + getCheckoutOptionsNotifyFlags , + setCheckoutOptionsNotifyFlags , + + +-- ** ourLabel #attr:ourLabel# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsOurLabelPropertyInfo , +#endif +#if ENABLE_OVERLOADING + checkoutOptionsOurLabel , +#endif + clearCheckoutOptionsOurLabel , + constructCheckoutOptionsOurLabel , + getCheckoutOptionsOurLabel , + setCheckoutOptionsOurLabel , + + +-- ** strategy #attr:strategy# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsStrategyPropertyInfo , +#endif +#if ENABLE_OVERLOADING + checkoutOptionsStrategy , +#endif + constructCheckoutOptionsStrategy , + getCheckoutOptionsStrategy , + setCheckoutOptionsStrategy , + + +-- ** targetDirectory #attr:targetDirectory# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsTargetDirectoryPropertyInfo, +#endif +#if ENABLE_OVERLOADING + checkoutOptionsTargetDirectory , +#endif + clearCheckoutOptionsTargetDirectory , + constructCheckoutOptionsTargetDirectory , + getCheckoutOptionsTargetDirectory , + setCheckoutOptionsTargetDirectory , + + +-- ** theirLabel #attr:theirLabel# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CheckoutOptionsTheirLabelPropertyInfo , +#endif +#if ENABLE_OVERLOADING + checkoutOptionsTheirLabel , +#endif + clearCheckoutOptionsTheirLabel , + constructCheckoutOptionsTheirLabel , + getCheckoutOptionsTheirLabel , + setCheckoutOptionsTheirLabel , + + + + + ) 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.Tree as Ggit.Tree + +-- | Memory-managed wrapper type. +newtype CheckoutOptions = CheckoutOptions (ManagedPtr CheckoutOptions) +foreign import ccall "ggit_checkout_options_get_type" + c_ggit_checkout_options_get_type :: IO GType + +instance GObject CheckoutOptions where + gobjectType = c_ggit_checkout_options_get_type + + +-- | Type class for types which can be safely cast to `CheckoutOptions`, for instance with `toCheckoutOptions`. +class (GObject o, O.IsDescendantOf CheckoutOptions o) => IsCheckoutOptions o +instance (GObject o, O.IsDescendantOf CheckoutOptions o) => IsCheckoutOptions o + +instance O.HasParentTypes CheckoutOptions +type instance O.ParentTypes CheckoutOptions = '[GObject.Object.Object] + +-- | Cast to `CheckoutOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCheckoutOptions :: (MonadIO m, IsCheckoutOptions o) => o -> m CheckoutOptions +toCheckoutOptions = liftIO . unsafeCastTo CheckoutOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `CheckoutOptions`. +noCheckoutOptions :: Maybe CheckoutOptions +noCheckoutOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCheckoutOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveCheckoutOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCheckoutOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCheckoutOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCheckoutOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCheckoutOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCheckoutOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCheckoutOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCheckoutOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCheckoutOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCheckoutOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCheckoutOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCheckoutOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCheckoutOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCheckoutOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCheckoutOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCheckoutOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCheckoutOptionsMethod "getAncestorLabel" o = CheckoutOptionsGetAncestorLabelMethodInfo + ResolveCheckoutOptionsMethod "getBaseline" o = CheckoutOptionsGetBaselineMethodInfo + ResolveCheckoutOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCheckoutOptionsMethod "getDirMode" o = CheckoutOptionsGetDirModeMethodInfo + ResolveCheckoutOptionsMethod "getDisableFilters" o = CheckoutOptionsGetDisableFiltersMethodInfo + ResolveCheckoutOptionsMethod "getFileMode" o = CheckoutOptionsGetFileModeMethodInfo + ResolveCheckoutOptionsMethod "getFileOpenFlags" o = CheckoutOptionsGetFileOpenFlagsMethodInfo + ResolveCheckoutOptionsMethod "getNotifyFlags" o = CheckoutOptionsGetNotifyFlagsMethodInfo + ResolveCheckoutOptionsMethod "getOurLabel" o = CheckoutOptionsGetOurLabelMethodInfo + ResolveCheckoutOptionsMethod "getPaths" o = CheckoutOptionsGetPathsMethodInfo + ResolveCheckoutOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCheckoutOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCheckoutOptionsMethod "getStrategy" o = CheckoutOptionsGetStrategyMethodInfo + ResolveCheckoutOptionsMethod "getTargetDirectory" o = CheckoutOptionsGetTargetDirectoryMethodInfo + ResolveCheckoutOptionsMethod "getTheirLabel" o = CheckoutOptionsGetTheirLabelMethodInfo + ResolveCheckoutOptionsMethod "setAncestorLabel" o = CheckoutOptionsSetAncestorLabelMethodInfo + ResolveCheckoutOptionsMethod "setBaseline" o = CheckoutOptionsSetBaselineMethodInfo + ResolveCheckoutOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCheckoutOptionsMethod "setDirMode" o = CheckoutOptionsSetDirModeMethodInfo + ResolveCheckoutOptionsMethod "setDisableFilters" o = CheckoutOptionsSetDisableFiltersMethodInfo + ResolveCheckoutOptionsMethod "setFileMode" o = CheckoutOptionsSetFileModeMethodInfo + ResolveCheckoutOptionsMethod "setFileOpenFlags" o = CheckoutOptionsSetFileOpenFlagsMethodInfo + ResolveCheckoutOptionsMethod "setNotifyFlags" o = CheckoutOptionsSetNotifyFlagsMethodInfo + ResolveCheckoutOptionsMethod "setOurLabel" o = CheckoutOptionsSetOurLabelMethodInfo + ResolveCheckoutOptionsMethod "setPaths" o = CheckoutOptionsSetPathsMethodInfo + ResolveCheckoutOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCheckoutOptionsMethod "setStrategy" o = CheckoutOptionsSetStrategyMethodInfo + ResolveCheckoutOptionsMethod "setTargetDirectory" o = CheckoutOptionsSetTargetDirectoryMethodInfo + ResolveCheckoutOptionsMethod "setTheirLabel" o = CheckoutOptionsSetTheirLabelMethodInfo + ResolveCheckoutOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCheckoutOptionsMethod t CheckoutOptions, O.MethodInfo info CheckoutOptions p) => OL.IsLabel t (CheckoutOptions -> 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 + +-- VVV Prop "ancestor-label" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@ancestor-label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #ancestorLabel +@ +-} +getCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text) +getCheckoutOptionsAncestorLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "ancestor-label" + +{- | +Set the value of the “@ancestor-label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #ancestorLabel 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m () +setCheckoutOptionsAncestorLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "ancestor-label" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@ancestor-label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsAncestorLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o) +constructCheckoutOptionsAncestorLabel val = B.Properties.constructObjectPropertyString "ancestor-label" (Just val) + +{- | +Set the value of the “@ancestor-label@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ancestorLabel +@ +-} +clearCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m () +clearCheckoutOptionsAncestorLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "ancestor-label" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CheckoutOptionsAncestorLabelPropertyInfo +instance AttrInfo CheckoutOptionsAncestorLabelPropertyInfo where + type AttrAllowedOps CheckoutOptionsAncestorLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CheckoutOptionsAncestorLabelPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CheckoutOptionsAncestorLabelPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsAncestorLabelPropertyInfo = (Maybe T.Text) + type AttrLabel CheckoutOptionsAncestorLabelPropertyInfo = "ancestor-label" + type AttrOrigin CheckoutOptionsAncestorLabelPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsAncestorLabel + attrSet _ = setCheckoutOptionsAncestorLabel + attrConstruct _ = constructCheckoutOptionsAncestorLabel + attrClear _ = clearCheckoutOptionsAncestorLabel +#endif + +-- VVV Prop "baseline" + -- Type: TInterface (Name {namespace = "Ggit", name = "Tree"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@baseline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #baseline +@ +-} +getCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe Ggit.Tree.Tree) +getCheckoutOptionsBaseline obj = liftIO $ B.Properties.getObjectPropertyObject obj "baseline" Ggit.Tree.Tree + +{- | +Set the value of the “@baseline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #baseline 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o, Ggit.Tree.IsTree a) => o -> a -> m () +setCheckoutOptionsBaseline obj val = liftIO $ B.Properties.setObjectPropertyObject obj "baseline" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@baseline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsBaseline :: (IsCheckoutOptions o, Ggit.Tree.IsTree a) => a -> IO (GValueConstruct o) +constructCheckoutOptionsBaseline val = B.Properties.constructObjectPropertyObject "baseline" (Just val) + +{- | +Set the value of the “@baseline@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #baseline +@ +-} +clearCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o) => o -> m () +clearCheckoutOptionsBaseline obj = liftIO $ B.Properties.setObjectPropertyObject obj "baseline" (Nothing :: Maybe Ggit.Tree.Tree) + +#if ENABLE_OVERLOADING +data CheckoutOptionsBaselinePropertyInfo +instance AttrInfo CheckoutOptionsBaselinePropertyInfo where + type AttrAllowedOps CheckoutOptionsBaselinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CheckoutOptionsBaselinePropertyInfo = Ggit.Tree.IsTree + type AttrBaseTypeConstraint CheckoutOptionsBaselinePropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsBaselinePropertyInfo = (Maybe Ggit.Tree.Tree) + type AttrLabel CheckoutOptionsBaselinePropertyInfo = "baseline" + type AttrOrigin CheckoutOptionsBaselinePropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsBaseline + attrSet _ = setCheckoutOptionsBaseline + attrConstruct _ = constructCheckoutOptionsBaseline + attrClear _ = clearCheckoutOptionsBaseline +#endif + +-- VVV Prop "dir-mode" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@dir-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #dirMode +@ +-} +getCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32 +getCheckoutOptionsDirMode obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "dir-mode" + +{- | +Set the value of the “@dir-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #dirMode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m () +setCheckoutOptionsDirMode obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "dir-mode" val + +{- | +Construct a `GValueConstruct` with valid value for the “@dir-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsDirMode :: (IsCheckoutOptions o) => Word32 -> IO (GValueConstruct o) +constructCheckoutOptionsDirMode val = B.Properties.constructObjectPropertyUInt32 "dir-mode" val + +#if ENABLE_OVERLOADING +data CheckoutOptionsDirModePropertyInfo +instance AttrInfo CheckoutOptionsDirModePropertyInfo where + type AttrAllowedOps CheckoutOptionsDirModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CheckoutOptionsDirModePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CheckoutOptionsDirModePropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsDirModePropertyInfo = Word32 + type AttrLabel CheckoutOptionsDirModePropertyInfo = "dir-mode" + type AttrOrigin CheckoutOptionsDirModePropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsDirMode + attrSet _ = setCheckoutOptionsDirMode + attrConstruct _ = constructCheckoutOptionsDirMode + attrClear _ = undefined +#endif + +-- VVV Prop "disable-filters" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@disable-filters@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #disableFilters +@ +-} +getCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> m Bool +getCheckoutOptionsDisableFilters obj = liftIO $ B.Properties.getObjectPropertyBool obj "disable-filters" + +{- | +Set the value of the “@disable-filters@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #disableFilters 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> Bool -> m () +setCheckoutOptionsDisableFilters obj val = liftIO $ B.Properties.setObjectPropertyBool obj "disable-filters" val + +{- | +Construct a `GValueConstruct` with valid value for the “@disable-filters@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsDisableFilters :: (IsCheckoutOptions o) => Bool -> IO (GValueConstruct o) +constructCheckoutOptionsDisableFilters val = B.Properties.constructObjectPropertyBool "disable-filters" val + +#if ENABLE_OVERLOADING +data CheckoutOptionsDisableFiltersPropertyInfo +instance AttrInfo CheckoutOptionsDisableFiltersPropertyInfo where + type AttrAllowedOps CheckoutOptionsDisableFiltersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CheckoutOptionsDisableFiltersPropertyInfo = (~) Bool + type AttrBaseTypeConstraint CheckoutOptionsDisableFiltersPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsDisableFiltersPropertyInfo = Bool + type AttrLabel CheckoutOptionsDisableFiltersPropertyInfo = "disable-filters" + type AttrOrigin CheckoutOptionsDisableFiltersPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsDisableFilters + attrSet _ = setCheckoutOptionsDisableFilters + attrConstruct _ = constructCheckoutOptionsDisableFilters + attrClear _ = undefined +#endif + +-- VVV Prop "file-mode" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@file-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #fileMode +@ +-} +getCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32 +getCheckoutOptionsFileMode obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "file-mode" + +{- | +Set the value of the “@file-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #fileMode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m () +setCheckoutOptionsFileMode obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "file-mode" val + +{- | +Construct a `GValueConstruct` with valid value for the “@file-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsFileMode :: (IsCheckoutOptions o) => Word32 -> IO (GValueConstruct o) +constructCheckoutOptionsFileMode val = B.Properties.constructObjectPropertyUInt32 "file-mode" val + +#if ENABLE_OVERLOADING +data CheckoutOptionsFileModePropertyInfo +instance AttrInfo CheckoutOptionsFileModePropertyInfo where + type AttrAllowedOps CheckoutOptionsFileModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CheckoutOptionsFileModePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CheckoutOptionsFileModePropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsFileModePropertyInfo = Word32 + type AttrLabel CheckoutOptionsFileModePropertyInfo = "file-mode" + type AttrOrigin CheckoutOptionsFileModePropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsFileMode + attrSet _ = setCheckoutOptionsFileMode + attrConstruct _ = constructCheckoutOptionsFileMode + attrClear _ = undefined +#endif + +-- VVV Prop "file-open-flags" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@file-open-flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #fileOpenFlags +@ +-} +getCheckoutOptionsFileOpenFlags :: (MonadIO m, IsCheckoutOptions o) => o -> m Int32 +getCheckoutOptionsFileOpenFlags obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "file-open-flags" + +{- | +Set the value of the “@file-open-flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #fileOpenFlags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsFileOpenFlags :: (MonadIO m, IsCheckoutOptions o) => o -> Int32 -> m () +setCheckoutOptionsFileOpenFlags obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "file-open-flags" val + +{- | +Construct a `GValueConstruct` with valid value for the “@file-open-flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsFileOpenFlags :: (IsCheckoutOptions o) => Int32 -> IO (GValueConstruct o) +constructCheckoutOptionsFileOpenFlags val = B.Properties.constructObjectPropertyInt32 "file-open-flags" val + +#if ENABLE_OVERLOADING +data CheckoutOptionsFileOpenFlagsPropertyInfo +instance AttrInfo CheckoutOptionsFileOpenFlagsPropertyInfo where + type AttrAllowedOps CheckoutOptionsFileOpenFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CheckoutOptionsFileOpenFlagsPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint CheckoutOptionsFileOpenFlagsPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsFileOpenFlagsPropertyInfo = Int32 + type AttrLabel CheckoutOptionsFileOpenFlagsPropertyInfo = "file-open-flags" + type AttrOrigin CheckoutOptionsFileOpenFlagsPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsFileOpenFlags + attrSet _ = setCheckoutOptionsFileOpenFlags + attrConstruct _ = constructCheckoutOptionsFileOpenFlags + attrClear _ = undefined +#endif + +-- VVV Prop "notify-flags" + -- Type: TInterface (Name {namespace = "Ggit", name = "CheckoutNotifyFlags"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@notify-flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #notifyFlags +@ +-} +getCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> m [Ggit.Flags.CheckoutNotifyFlags] +getCheckoutOptionsNotifyFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "notify-flags" + +{- | +Set the value of the “@notify-flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #notifyFlags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> [Ggit.Flags.CheckoutNotifyFlags] -> m () +setCheckoutOptionsNotifyFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "notify-flags" val + +{- | +Construct a `GValueConstruct` with valid value for the “@notify-flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsNotifyFlags :: (IsCheckoutOptions o) => [Ggit.Flags.CheckoutNotifyFlags] -> IO (GValueConstruct o) +constructCheckoutOptionsNotifyFlags val = B.Properties.constructObjectPropertyFlags "notify-flags" val + +#if ENABLE_OVERLOADING +data CheckoutOptionsNotifyFlagsPropertyInfo +instance AttrInfo CheckoutOptionsNotifyFlagsPropertyInfo where + type AttrAllowedOps CheckoutOptionsNotifyFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CheckoutOptionsNotifyFlagsPropertyInfo = (~) [Ggit.Flags.CheckoutNotifyFlags] + type AttrBaseTypeConstraint CheckoutOptionsNotifyFlagsPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsNotifyFlagsPropertyInfo = [Ggit.Flags.CheckoutNotifyFlags] + type AttrLabel CheckoutOptionsNotifyFlagsPropertyInfo = "notify-flags" + type AttrOrigin CheckoutOptionsNotifyFlagsPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsNotifyFlags + attrSet _ = setCheckoutOptionsNotifyFlags + attrConstruct _ = constructCheckoutOptionsNotifyFlags + attrClear _ = undefined +#endif + +-- VVV Prop "our-label" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@our-label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #ourLabel +@ +-} +getCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text) +getCheckoutOptionsOurLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "our-label" + +{- | +Set the value of the “@our-label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #ourLabel 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m () +setCheckoutOptionsOurLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "our-label" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@our-label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsOurLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o) +constructCheckoutOptionsOurLabel val = B.Properties.constructObjectPropertyString "our-label" (Just val) + +{- | +Set the value of the “@our-label@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #ourLabel +@ +-} +clearCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m () +clearCheckoutOptionsOurLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "our-label" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CheckoutOptionsOurLabelPropertyInfo +instance AttrInfo CheckoutOptionsOurLabelPropertyInfo where + type AttrAllowedOps CheckoutOptionsOurLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CheckoutOptionsOurLabelPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CheckoutOptionsOurLabelPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsOurLabelPropertyInfo = (Maybe T.Text) + type AttrLabel CheckoutOptionsOurLabelPropertyInfo = "our-label" + type AttrOrigin CheckoutOptionsOurLabelPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsOurLabel + attrSet _ = setCheckoutOptionsOurLabel + attrConstruct _ = constructCheckoutOptionsOurLabel + attrClear _ = clearCheckoutOptionsOurLabel +#endif + +-- VVV Prop "strategy" + -- Type: TInterface (Name {namespace = "Ggit", name = "CheckoutStrategy"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@strategy@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #strategy +@ +-} +getCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> m [Ggit.Flags.CheckoutStrategy] +getCheckoutOptionsStrategy obj = liftIO $ B.Properties.getObjectPropertyFlags obj "strategy" + +{- | +Set the value of the “@strategy@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #strategy 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> [Ggit.Flags.CheckoutStrategy] -> m () +setCheckoutOptionsStrategy obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "strategy" val + +{- | +Construct a `GValueConstruct` with valid value for the “@strategy@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsStrategy :: (IsCheckoutOptions o) => [Ggit.Flags.CheckoutStrategy] -> IO (GValueConstruct o) +constructCheckoutOptionsStrategy val = B.Properties.constructObjectPropertyFlags "strategy" val + +#if ENABLE_OVERLOADING +data CheckoutOptionsStrategyPropertyInfo +instance AttrInfo CheckoutOptionsStrategyPropertyInfo where + type AttrAllowedOps CheckoutOptionsStrategyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CheckoutOptionsStrategyPropertyInfo = (~) [Ggit.Flags.CheckoutStrategy] + type AttrBaseTypeConstraint CheckoutOptionsStrategyPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsStrategyPropertyInfo = [Ggit.Flags.CheckoutStrategy] + type AttrLabel CheckoutOptionsStrategyPropertyInfo = "strategy" + type AttrOrigin CheckoutOptionsStrategyPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsStrategy + attrSet _ = setCheckoutOptionsStrategy + attrConstruct _ = constructCheckoutOptionsStrategy + attrClear _ = undefined +#endif + +-- VVV Prop "target-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@target-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #targetDirectory +@ +-} +getCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text) +getCheckoutOptionsTargetDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "target-directory" + +{- | +Set the value of the “@target-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #targetDirectory 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m () +setCheckoutOptionsTargetDirectory obj val = liftIO $ B.Properties.setObjectPropertyString obj "target-directory" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@target-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsTargetDirectory :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o) +constructCheckoutOptionsTargetDirectory val = B.Properties.constructObjectPropertyString "target-directory" (Just val) + +{- | +Set the value of the “@target-directory@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #targetDirectory +@ +-} +clearCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m () +clearCheckoutOptionsTargetDirectory obj = liftIO $ B.Properties.setObjectPropertyString obj "target-directory" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CheckoutOptionsTargetDirectoryPropertyInfo +instance AttrInfo CheckoutOptionsTargetDirectoryPropertyInfo where + type AttrAllowedOps CheckoutOptionsTargetDirectoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CheckoutOptionsTargetDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CheckoutOptionsTargetDirectoryPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsTargetDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel CheckoutOptionsTargetDirectoryPropertyInfo = "target-directory" + type AttrOrigin CheckoutOptionsTargetDirectoryPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsTargetDirectory + attrSet _ = setCheckoutOptionsTargetDirectory + attrConstruct _ = constructCheckoutOptionsTargetDirectory + attrClear _ = clearCheckoutOptionsTargetDirectory +#endif + +-- VVV Prop "their-label" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@their-label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' checkoutOptions #theirLabel +@ +-} +getCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe T.Text) +getCheckoutOptionsTheirLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "their-label" + +{- | +Set the value of the “@their-label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' checkoutOptions [ #theirLabel 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> T.Text -> m () +setCheckoutOptionsTheirLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "their-label" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@their-label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCheckoutOptionsTheirLabel :: (IsCheckoutOptions o) => T.Text -> IO (GValueConstruct o) +constructCheckoutOptionsTheirLabel val = B.Properties.constructObjectPropertyString "their-label" (Just val) + +{- | +Set the value of the “@their-label@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #theirLabel +@ +-} +clearCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m () +clearCheckoutOptionsTheirLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "their-label" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CheckoutOptionsTheirLabelPropertyInfo +instance AttrInfo CheckoutOptionsTheirLabelPropertyInfo where + type AttrAllowedOps CheckoutOptionsTheirLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CheckoutOptionsTheirLabelPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CheckoutOptionsTheirLabelPropertyInfo = IsCheckoutOptions + type AttrGetType CheckoutOptionsTheirLabelPropertyInfo = (Maybe T.Text) + type AttrLabel CheckoutOptionsTheirLabelPropertyInfo = "their-label" + type AttrOrigin CheckoutOptionsTheirLabelPropertyInfo = CheckoutOptions + attrGet _ = getCheckoutOptionsTheirLabel + attrSet _ = setCheckoutOptionsTheirLabel + attrConstruct _ = constructCheckoutOptionsTheirLabel + attrClear _ = clearCheckoutOptionsTheirLabel +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CheckoutOptions +type instance O.AttributeList CheckoutOptions = CheckoutOptionsAttributeList +type CheckoutOptionsAttributeList = ('[ '("ancestorLabel", CheckoutOptionsAncestorLabelPropertyInfo), '("baseline", CheckoutOptionsBaselinePropertyInfo), '("dirMode", CheckoutOptionsDirModePropertyInfo), '("disableFilters", CheckoutOptionsDisableFiltersPropertyInfo), '("fileMode", CheckoutOptionsFileModePropertyInfo), '("fileOpenFlags", CheckoutOptionsFileOpenFlagsPropertyInfo), '("notifyFlags", CheckoutOptionsNotifyFlagsPropertyInfo), '("ourLabel", CheckoutOptionsOurLabelPropertyInfo), '("strategy", CheckoutOptionsStrategyPropertyInfo), '("targetDirectory", CheckoutOptionsTargetDirectoryPropertyInfo), '("theirLabel", CheckoutOptionsTheirLabelPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +checkoutOptionsAncestorLabel :: AttrLabelProxy "ancestorLabel" +checkoutOptionsAncestorLabel = AttrLabelProxy + +checkoutOptionsBaseline :: AttrLabelProxy "baseline" +checkoutOptionsBaseline = AttrLabelProxy + +checkoutOptionsDirMode :: AttrLabelProxy "dirMode" +checkoutOptionsDirMode = AttrLabelProxy + +checkoutOptionsDisableFilters :: AttrLabelProxy "disableFilters" +checkoutOptionsDisableFilters = AttrLabelProxy + +checkoutOptionsFileMode :: AttrLabelProxy "fileMode" +checkoutOptionsFileMode = AttrLabelProxy + +checkoutOptionsFileOpenFlags :: AttrLabelProxy "fileOpenFlags" +checkoutOptionsFileOpenFlags = AttrLabelProxy + +checkoutOptionsNotifyFlags :: AttrLabelProxy "notifyFlags" +checkoutOptionsNotifyFlags = AttrLabelProxy + +checkoutOptionsOurLabel :: AttrLabelProxy "ourLabel" +checkoutOptionsOurLabel = AttrLabelProxy + +checkoutOptionsStrategy :: AttrLabelProxy "strategy" +checkoutOptionsStrategy = AttrLabelProxy + +checkoutOptionsTargetDirectory :: AttrLabelProxy "targetDirectory" +checkoutOptionsTargetDirectory = AttrLabelProxy + +checkoutOptionsTheirLabel :: AttrLabelProxy "theirLabel" +checkoutOptionsTheirLabel = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CheckoutOptions = CheckoutOptionsSignalList +type CheckoutOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CheckoutOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_new" ggit_checkout_options_new :: + IO (Ptr CheckoutOptions) + +{- | +Create a new checkout options object. +-} +checkoutOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe CheckoutOptions) + {- ^ __Returns:__ a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' or 'Nothing'. -} +checkoutOptionsNew = liftIO $ do + result <- ggit_checkout_options_new + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject CheckoutOptions) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method CheckoutOptions::get_ancestor_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_ancestor_label" ggit_checkout_options_get_ancestor_label :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO CString + +{- | +Get the checkout ancestor label. +-} +checkoutOptionsGetAncestorLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the checkout ancestor label or 'Nothing'. -} +checkoutOptionsGetAncestorLabel options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_ancestor_label options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetAncestorLabelMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetAncestorLabelMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetAncestorLabel + +#endif + +-- method CheckoutOptions::get_baseline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Tree"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_baseline" ggit_checkout_options_get_baseline :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO (Ptr Ggit.Tree.Tree) + +{- | +Get the baseline, i.e. the expected content of workdir. Defaults to HEAD. +-} +checkoutOptionsGetBaseline :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m (Maybe Ggit.Tree.Tree) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Tree.Tree' or 'Nothing'. -} +checkoutOptionsGetBaseline options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_baseline options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.Tree.Tree) result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetBaselineMethodInfo +instance (signature ~ (m (Maybe Ggit.Tree.Tree)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetBaselineMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetBaseline + +#endif + +-- method CheckoutOptions::get_dir_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_dir_mode" ggit_checkout_options_get_dir_mode :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO Word32 + +{- | +Get the default checkout directory mode. +-} +checkoutOptionsGetDirMode :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m Word32 + {- ^ __Returns:__ the default directory mode. -} +checkoutOptionsGetDirMode options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_dir_mode options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetDirModeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetDirModeMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetDirMode + +#endif + +-- method CheckoutOptions::get_disable_filters +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_disable_filters" ggit_checkout_options_get_disable_filters :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO CInt + +{- | +Get whether filters are disabled. +-} +checkoutOptionsGetDisableFilters :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m Bool + {- ^ __Returns:__ 'True' if filters are disabled, 'False' otherwise. -} +checkoutOptionsGetDisableFilters options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_disable_filters options' + let result' = (/= 0) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetDisableFiltersMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetDisableFiltersMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetDisableFilters + +#endif + +-- method CheckoutOptions::get_file_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_file_mode" ggit_checkout_options_get_file_mode :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO Word32 + +{- | +Get the default checkout file mode. +-} +checkoutOptionsGetFileMode :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m Word32 + {- ^ __Returns:__ the default checkout file mode. -} +checkoutOptionsGetFileMode options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_file_mode options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetFileModeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetFileModeMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetFileMode + +#endif + +-- method CheckoutOptions::get_file_open_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_file_open_flags" ggit_checkout_options_get_file_open_flags :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO Int32 + +{- | +Get the checkout file open flags. These flags are platform specific, +e.g. on Unix these would include O_CREAT, O_TRUNC, etc. +-} +checkoutOptionsGetFileOpenFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m Int32 + {- ^ __Returns:__ the checkout file open flags. -} +checkoutOptionsGetFileOpenFlags options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_file_open_flags options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetFileOpenFlagsMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetFileOpenFlagsMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetFileOpenFlags + +#endif + +-- method CheckoutOptions::get_notify_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CheckoutNotifyFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_notify_flags" ggit_checkout_options_get_notify_flags :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO CUInt + +{- | +Get the checkout notify flags. +-} +checkoutOptionsGetNotifyFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m [Ggit.Flags.CheckoutNotifyFlags] + {- ^ __Returns:__ a 'GI.Ggit.Flags.CheckoutNotifyFlags'. -} +checkoutOptionsGetNotifyFlags options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_notify_flags options' + let result' = wordToGFlags result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetNotifyFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.CheckoutNotifyFlags]), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetNotifyFlagsMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetNotifyFlags + +#endif + +-- method CheckoutOptions::get_our_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_our_label" ggit_checkout_options_get_our_label :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO CString + +{- | +Get the checkout our label. +-} +checkoutOptionsGetOurLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the checkout our label or 'Nothing'. -} +checkoutOptionsGetOurLabel options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_our_label options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetOurLabelMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetOurLabelMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetOurLabel + +#endif + +-- method CheckoutOptions::get_paths +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_paths" ggit_checkout_options_get_paths :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO (Ptr CString) + +{- | +Get the list of file paths to checkout. +-} +checkoutOptionsGetPaths :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a 'Nothing' terminated list of file paths, or 'Nothing'. -} +checkoutOptionsGetPaths options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_paths options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetPathsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetPathsMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetPaths + +#endif + +-- method CheckoutOptions::get_strategy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CheckoutStrategy"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_strategy" ggit_checkout_options_get_strategy :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO CUInt + +{- | +Get the checkout strategy. +-} +checkoutOptionsGetStrategy :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m [Ggit.Flags.CheckoutStrategy] + {- ^ __Returns:__ a 'GI.Ggit.Flags.CheckoutStrategy'. -} +checkoutOptionsGetStrategy options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_strategy options' + let result' = wordToGFlags result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetStrategyMethodInfo +instance (signature ~ (m [Ggit.Flags.CheckoutStrategy]), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetStrategyMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetStrategy + +#endif + +-- method CheckoutOptions::get_target_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_target_directory" ggit_checkout_options_get_target_directory :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO CString + +{- | +Get the checkout target directory. +-} +checkoutOptionsGetTargetDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the checkout target directory or 'Nothing'. -} +checkoutOptionsGetTargetDirectory options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_target_directory options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetTargetDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetTargetDirectoryMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetTargetDirectory + +#endif + +-- method CheckoutOptions::get_their_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_get_their_label" ggit_checkout_options_get_their_label :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO CString + +{- | +Get the checkout their label. +-} +checkoutOptionsGetTheirLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the checkout their label or 'Nothing'. -} +checkoutOptionsGetTheirLabel options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_checkout_options_get_their_label options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data CheckoutOptionsGetTheirLabelMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsGetTheirLabelMethodInfo a signature where + overloadedMethod _ = checkoutOptionsGetTheirLabel + +#endif + +-- method CheckoutOptions::set_ancestor_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the ancestor label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_ancestor_label" ggit_checkout_options_set_ancestor_label :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + CString -> -- label : TBasicType TUTF8 + IO () + +{- | +Set the checkout ancestor label. +-} +checkoutOptionsSetAncestorLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Maybe (T.Text) + {- ^ /@label@/: the ancestor label. -} + -> m () +checkoutOptionsSetAncestorLabel options label = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeLabel <- case label of + Nothing -> return nullPtr + Just jLabel -> do + jLabel' <- textToCString jLabel + return jLabel' + ggit_checkout_options_set_ancestor_label options' maybeLabel + touchManagedPtr options + freeMem maybeLabel + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetAncestorLabelMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetAncestorLabelMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetAncestorLabel + +#endif + +-- method CheckoutOptions::set_baseline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_baseline" ggit_checkout_options_set_baseline :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Ptr Ggit.Tree.Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + IO () + +{- | +Set the baseline, i.e. the expected content of workdir. If /@tree@/ is set +to 'Nothing', the default (HEAD) will be used as the baseline. +-} +checkoutOptionsSetBaseline :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a, Ggit.Tree.IsTree b) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Maybe (b) + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> m () +checkoutOptionsSetBaseline options tree = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeTree <- case tree of + Nothing -> return nullPtr + Just jTree -> do + jTree' <- unsafeManagedPtrCastPtr jTree + return jTree' + ggit_checkout_options_set_baseline options' maybeTree + touchManagedPtr options + whenJust tree touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetBaselineMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCheckoutOptions a, Ggit.Tree.IsTree b) => O.MethodInfo CheckoutOptionsSetBaselineMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetBaseline + +#endif + +-- method CheckoutOptions::set_dir_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir_mode", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the dir mode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_dir_mode" ggit_checkout_options_set_dir_mode :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Word32 -> -- dir_mode : TBasicType TUInt + IO () + +{- | +Set the default checkout directory mode. +-} +checkoutOptionsSetDirMode :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Word32 + {- ^ /@dirMode@/: the dir mode. -} + -> m () +checkoutOptionsSetDirMode options dirMode = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_checkout_options_set_dir_mode options' dirMode + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetDirModeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetDirModeMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetDirMode + +#endif + +-- method CheckoutOptions::set_disable_filters +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "disable filters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_disable_filters" ggit_checkout_options_set_disable_filters :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + CInt -> -- disable : TBasicType TBoolean + IO () + +{- | +Set whether to disable filters. +-} +checkoutOptionsSetDisableFilters :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Bool + {- ^ /@disable@/: disable filters. -} + -> m () +checkoutOptionsSetDisableFilters options disable = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let disable' = (fromIntegral . fromEnum) disable + ggit_checkout_options_set_disable_filters options' disable' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetDisableFiltersMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetDisableFiltersMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetDisableFilters + +#endif + +-- method CheckoutOptions::set_file_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_mode", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file mode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_file_mode" ggit_checkout_options_set_file_mode :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Word32 -> -- file_mode : TBasicType TUInt + IO () + +{- | +Set the default checkout file mode. +-} +checkoutOptionsSetFileMode :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Word32 + {- ^ /@fileMode@/: the file mode. -} + -> m () +checkoutOptionsSetFileMode options fileMode = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_checkout_options_set_file_mode options' fileMode + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetFileModeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetFileModeMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetFileMode + +#endif + +-- method CheckoutOptions::set_file_open_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file open flags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_file_open_flags" ggit_checkout_options_set_file_open_flags :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Int32 -> -- flags : TBasicType TInt + IO () + +{- | +Set the checkout file open flags. These flags are platform dependent, +e.g. on Unix use O_CREAT, O_TRUNC, etc. +-} +checkoutOptionsSetFileOpenFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Int32 + {- ^ /@flags@/: the file open flags. -} + -> m () +checkoutOptionsSetFileOpenFlags options flags = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_checkout_options_set_file_open_flags options' flags + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetFileOpenFlagsMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetFileOpenFlagsMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetFileOpenFlags + +#endif + +-- method CheckoutOptions::set_notify_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutNotifyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutNotifyFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_notify_flags" ggit_checkout_options_set_notify_flags :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "CheckoutNotifyFlags"}) + IO () + +{- | +Set the checkout notify flags. +-} +checkoutOptionsSetNotifyFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> [Ggit.Flags.CheckoutNotifyFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.CheckoutNotifyFlags'. -} + -> m () +checkoutOptionsSetNotifyFlags options flags = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let flags' = gflagsToWord flags + ggit_checkout_options_set_notify_flags options' flags' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetNotifyFlagsMethodInfo +instance (signature ~ ([Ggit.Flags.CheckoutNotifyFlags] -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetNotifyFlagsMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetNotifyFlags + +#endif + +-- method CheckoutOptions::set_our_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the our label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_our_label" ggit_checkout_options_set_our_label :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + CString -> -- label : TBasicType TUTF8 + IO () + +{- | +Set the checkout our label. +-} +checkoutOptionsSetOurLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Maybe (T.Text) + {- ^ /@label@/: the our label. -} + -> m () +checkoutOptionsSetOurLabel options label = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeLabel <- case label of + Nothing -> return nullPtr + Just jLabel -> do + jLabel' <- textToCString jLabel + return jLabel' + ggit_checkout_options_set_our_label options' maybeLabel + touchManagedPtr options + freeMem maybeLabel + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetOurLabelMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetOurLabelMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetOurLabel + +#endif + +-- method CheckoutOptions::set_paths +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paths", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %NULL terminated list of paths.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_paths" ggit_checkout_options_set_paths :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Ptr CString -> -- paths : TCArray True (-1) (-1) (TBasicType TUTF8) + IO () + +{- | +Set the list of file paths to checkout. If /@paths@/ is 'Nothing', then all files +will be checked out. +-} +checkoutOptionsSetPaths :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Maybe ([T.Text]) + {- ^ /@paths@/: a 'Nothing' terminated list of paths. -} + -> m () +checkoutOptionsSetPaths options paths = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybePaths <- case paths of + Nothing -> return nullPtr + Just jPaths -> do + jPaths' <- packZeroTerminatedUTF8CArray jPaths + return jPaths' + ggit_checkout_options_set_paths options' maybePaths + touchManagedPtr options + mapZeroTerminatedCArray freeMem maybePaths + freeMem maybePaths + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetPathsMethodInfo +instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetPathsMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetPaths + +#endif + +-- method CheckoutOptions::set_strategy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "strategy", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutStrategy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutStrategy.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_strategy" ggit_checkout_options_set_strategy :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + CUInt -> -- strategy : TInterface (Name {namespace = "Ggit", name = "CheckoutStrategy"}) + IO () + +{- | +Set the checkout strategy. +-} +checkoutOptionsSetStrategy :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> [Ggit.Flags.CheckoutStrategy] + {- ^ /@strategy@/: a 'GI.Ggit.Flags.CheckoutStrategy'. -} + -> m () +checkoutOptionsSetStrategy options strategy = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let strategy' = gflagsToWord strategy + ggit_checkout_options_set_strategy options' strategy' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetStrategyMethodInfo +instance (signature ~ ([Ggit.Flags.CheckoutStrategy] -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetStrategyMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetStrategy + +#endif + +-- method CheckoutOptions::set_target_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the target directory.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_target_directory" ggit_checkout_options_set_target_directory :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + CString -> -- directory : TBasicType TUTF8 + IO () + +{- | +Set the checkout target directory. +-} +checkoutOptionsSetTargetDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Maybe (T.Text) + {- ^ /@directory@/: the target directory. -} + -> m () +checkoutOptionsSetTargetDirectory options directory = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeDirectory <- case directory of + Nothing -> return nullPtr + Just jDirectory -> do + jDirectory' <- textToCString jDirectory + return jDirectory' + ggit_checkout_options_set_target_directory options' maybeDirectory + touchManagedPtr options + freeMem maybeDirectory + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetTargetDirectoryMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetTargetDirectoryMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetTargetDirectory + +#endif + +-- method CheckoutOptions::set_their_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the their label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_checkout_options_set_their_label" ggit_checkout_options_set_their_label :: + Ptr CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + CString -> -- label : TBasicType TUTF8 + IO () + +{- | +Set the checkout their label. +-} +checkoutOptionsSetTheirLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsCheckoutOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> Maybe (T.Text) + {- ^ /@label@/: the their label. -} + -> m () +checkoutOptionsSetTheirLabel options label = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeLabel <- case label of + Nothing -> return nullPtr + Just jLabel -> do + jLabel' <- textToCString jLabel + return jLabel' + ggit_checkout_options_set_their_label options' maybeLabel + touchManagedPtr options + freeMem maybeLabel + return () + +#if ENABLE_OVERLOADING +data CheckoutOptionsSetTheirLabelMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCheckoutOptions a) => O.MethodInfo CheckoutOptionsSetTheirLabelMethodInfo a signature where + overloadedMethod _ = checkoutOptionsSetTheirLabel + +#endif + + diff --git a/GI/Ggit/Objects/CheckoutOptions.hs-boot b/GI/Ggit/Objects/CheckoutOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CheckoutOptions.hs-boot @@ -0,0 +1,134 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.CheckoutOptions 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 + +newtype CheckoutOptions = CheckoutOptions (ManagedPtr CheckoutOptions) +instance GObject CheckoutOptions where +class (GObject o, O.IsDescendantOf CheckoutOptions o) => IsCheckoutOptions o +instance (GObject o, O.IsDescendantOf CheckoutOptions o) => IsCheckoutOptions o +instance O.HasParentTypes CheckoutOptions +#if ENABLE_OVERLOADING +data CheckoutOptionsAncestorLabelPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsBaselinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsDirModePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsDisableFiltersPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsFileModePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsFileOpenFlagsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsNotifyFlagsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsOurLabelPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsStrategyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsTargetDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsTheirLabelPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetAncestorLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetBaselineMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetDirModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetDisableFiltersMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetFileModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetFileOpenFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetNotifyFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetOurLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetPathsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetStrategyMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetTargetDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsGetTheirLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetAncestorLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetBaselineMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetDirModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetDisableFiltersMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetFileModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetFileOpenFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetNotifyFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetOurLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetPathsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetStrategyMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetTargetDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data CheckoutOptionsSetTheirLabelMethodInfo +#endif diff --git a/GI/Ggit/Objects/CherryPickOptions.hs b/GI/Ggit/Objects/CherryPickOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CherryPickOptions.hs @@ -0,0 +1,660 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when doign a cherry-pick. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.CherryPickOptions + ( + +-- * Exported types + CherryPickOptions(..) , + IsCherryPickOptions , + toCherryPickOptions , + noCherryPickOptions , + + + -- * Methods +-- ** getCheckoutOptions #method:getCheckoutOptions# + +#if ENABLE_OVERLOADING + CherryPickOptionsGetCheckoutOptionsMethodInfo, +#endif + cherryPickOptionsGetCheckoutOptions , + + +-- ** getMainline #method:getMainline# + +#if ENABLE_OVERLOADING + CherryPickOptionsGetMainlineMethodInfo , +#endif + cherryPickOptionsGetMainline , + + +-- ** getMergeOptions #method:getMergeOptions# + +#if ENABLE_OVERLOADING + CherryPickOptionsGetMergeOptionsMethodInfo, +#endif + cherryPickOptionsGetMergeOptions , + + +-- ** new #method:new# + + cherryPickOptionsNew , + + +-- ** setCheckoutOptions #method:setCheckoutOptions# + +#if ENABLE_OVERLOADING + CherryPickOptionsSetCheckoutOptionsMethodInfo, +#endif + cherryPickOptionsSetCheckoutOptions , + + +-- ** setMainline #method:setMainline# + +#if ENABLE_OVERLOADING + CherryPickOptionsSetMainlineMethodInfo , +#endif + cherryPickOptionsSetMainline , + + +-- ** setMergeOptions #method:setMergeOptions# + +#if ENABLE_OVERLOADING + CherryPickOptionsSetMergeOptionsMethodInfo, +#endif + cherryPickOptionsSetMergeOptions , + + + + + -- * Properties +-- ** checkoutOptions #attr:checkoutOptions# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CherryPickOptionsCheckoutOptionsPropertyInfo, +#endif +#if ENABLE_OVERLOADING + cherryPickOptionsCheckoutOptions , +#endif + clearCherryPickOptionsCheckoutOptions , + constructCherryPickOptionsCheckoutOptions, + getCherryPickOptionsCheckoutOptions , + setCherryPickOptionsCheckoutOptions , + + +-- ** mainline #attr:mainline# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CherryPickOptionsMainlinePropertyInfo , +#endif +#if ENABLE_OVERLOADING + cherryPickOptionsMainline , +#endif + constructCherryPickOptionsMainline , + getCherryPickOptionsMainline , + setCherryPickOptionsMainline , + + +-- ** mergeOptions #attr:mergeOptions# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CherryPickOptionsMergeOptionsPropertyInfo, +#endif +#if ENABLE_OVERLOADING + cherryPickOptionsMergeOptions , +#endif + clearCherryPickOptionsMergeOptions , + constructCherryPickOptionsMergeOptions , + getCherryPickOptionsMergeOptions , + setCherryPickOptionsMergeOptions , + + + + + ) 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.Objects.CheckoutOptions as Ggit.CheckoutOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.MergeOptions as Ggit.MergeOptions + +-- | Memory-managed wrapper type. +newtype CherryPickOptions = CherryPickOptions (ManagedPtr CherryPickOptions) +foreign import ccall "ggit_cherry_pick_options_get_type" + c_ggit_cherry_pick_options_get_type :: IO GType + +instance GObject CherryPickOptions where + gobjectType = c_ggit_cherry_pick_options_get_type + + +-- | Type class for types which can be safely cast to `CherryPickOptions`, for instance with `toCherryPickOptions`. +class (GObject o, O.IsDescendantOf CherryPickOptions o) => IsCherryPickOptions o +instance (GObject o, O.IsDescendantOf CherryPickOptions o) => IsCherryPickOptions o + +instance O.HasParentTypes CherryPickOptions +type instance O.ParentTypes CherryPickOptions = '[GObject.Object.Object] + +-- | Cast to `CherryPickOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCherryPickOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m CherryPickOptions +toCherryPickOptions = liftIO . unsafeCastTo CherryPickOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `CherryPickOptions`. +noCherryPickOptions :: Maybe CherryPickOptions +noCherryPickOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCherryPickOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveCherryPickOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCherryPickOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCherryPickOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCherryPickOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCherryPickOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCherryPickOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCherryPickOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCherryPickOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCherryPickOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCherryPickOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCherryPickOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCherryPickOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCherryPickOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCherryPickOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCherryPickOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCherryPickOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCherryPickOptionsMethod "getCheckoutOptions" o = CherryPickOptionsGetCheckoutOptionsMethodInfo + ResolveCherryPickOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCherryPickOptionsMethod "getMainline" o = CherryPickOptionsGetMainlineMethodInfo + ResolveCherryPickOptionsMethod "getMergeOptions" o = CherryPickOptionsGetMergeOptionsMethodInfo + ResolveCherryPickOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCherryPickOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCherryPickOptionsMethod "setCheckoutOptions" o = CherryPickOptionsSetCheckoutOptionsMethodInfo + ResolveCherryPickOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCherryPickOptionsMethod "setMainline" o = CherryPickOptionsSetMainlineMethodInfo + ResolveCherryPickOptionsMethod "setMergeOptions" o = CherryPickOptionsSetMergeOptionsMethodInfo + ResolveCherryPickOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCherryPickOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCherryPickOptionsMethod t CherryPickOptions, O.MethodInfo info CherryPickOptions p) => OL.IsLabel t (CherryPickOptions -> 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 + +-- VVV Prop "checkout-options" + -- Type: TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@checkout-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cherryPickOptions #checkoutOptions +@ +-} +getCherryPickOptionsCheckoutOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m Ggit.CheckoutOptions.CheckoutOptions +getCherryPickOptionsCheckoutOptions obj = liftIO $ checkUnexpectedNothing "getCherryPickOptionsCheckoutOptions" $ B.Properties.getObjectPropertyObject obj "checkout-options" Ggit.CheckoutOptions.CheckoutOptions + +{- | +Set the value of the “@checkout-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cherryPickOptions [ #checkoutOptions 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCherryPickOptionsCheckoutOptions :: (MonadIO m, IsCherryPickOptions o, Ggit.CheckoutOptions.IsCheckoutOptions a) => o -> a -> m () +setCherryPickOptionsCheckoutOptions obj val = liftIO $ B.Properties.setObjectPropertyObject obj "checkout-options" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@checkout-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCherryPickOptionsCheckoutOptions :: (IsCherryPickOptions o, Ggit.CheckoutOptions.IsCheckoutOptions a) => a -> IO (GValueConstruct o) +constructCherryPickOptionsCheckoutOptions val = B.Properties.constructObjectPropertyObject "checkout-options" (Just val) + +{- | +Set the value of the “@checkout-options@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #checkoutOptions +@ +-} +clearCherryPickOptionsCheckoutOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m () +clearCherryPickOptionsCheckoutOptions obj = liftIO $ B.Properties.setObjectPropertyObject obj "checkout-options" (Nothing :: Maybe Ggit.CheckoutOptions.CheckoutOptions) + +#if ENABLE_OVERLOADING +data CherryPickOptionsCheckoutOptionsPropertyInfo +instance AttrInfo CherryPickOptionsCheckoutOptionsPropertyInfo where + type AttrAllowedOps CherryPickOptionsCheckoutOptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CherryPickOptionsCheckoutOptionsPropertyInfo = Ggit.CheckoutOptions.IsCheckoutOptions + type AttrBaseTypeConstraint CherryPickOptionsCheckoutOptionsPropertyInfo = IsCherryPickOptions + type AttrGetType CherryPickOptionsCheckoutOptionsPropertyInfo = Ggit.CheckoutOptions.CheckoutOptions + type AttrLabel CherryPickOptionsCheckoutOptionsPropertyInfo = "checkout-options" + type AttrOrigin CherryPickOptionsCheckoutOptionsPropertyInfo = CherryPickOptions + attrGet _ = getCherryPickOptionsCheckoutOptions + attrSet _ = setCherryPickOptionsCheckoutOptions + attrConstruct _ = constructCherryPickOptionsCheckoutOptions + attrClear _ = clearCherryPickOptionsCheckoutOptions +#endif + +-- VVV Prop "mainline" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@mainline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cherryPickOptions #mainline +@ +-} +getCherryPickOptionsMainline :: (MonadIO m, IsCherryPickOptions o) => o -> m Word32 +getCherryPickOptionsMainline obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "mainline" + +{- | +Set the value of the “@mainline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cherryPickOptions [ #mainline 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCherryPickOptionsMainline :: (MonadIO m, IsCherryPickOptions o) => o -> Word32 -> m () +setCherryPickOptionsMainline obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "mainline" val + +{- | +Construct a `GValueConstruct` with valid value for the “@mainline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCherryPickOptionsMainline :: (IsCherryPickOptions o) => Word32 -> IO (GValueConstruct o) +constructCherryPickOptionsMainline val = B.Properties.constructObjectPropertyUInt32 "mainline" val + +#if ENABLE_OVERLOADING +data CherryPickOptionsMainlinePropertyInfo +instance AttrInfo CherryPickOptionsMainlinePropertyInfo where + type AttrAllowedOps CherryPickOptionsMainlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CherryPickOptionsMainlinePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CherryPickOptionsMainlinePropertyInfo = IsCherryPickOptions + type AttrGetType CherryPickOptionsMainlinePropertyInfo = Word32 + type AttrLabel CherryPickOptionsMainlinePropertyInfo = "mainline" + type AttrOrigin CherryPickOptionsMainlinePropertyInfo = CherryPickOptions + attrGet _ = getCherryPickOptionsMainline + attrSet _ = setCherryPickOptionsMainline + attrConstruct _ = constructCherryPickOptionsMainline + attrClear _ = undefined +#endif + +-- VVV Prop "merge-options" + -- Type: TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@merge-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' cherryPickOptions #mergeOptions +@ +-} +getCherryPickOptionsMergeOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m (Maybe Ggit.MergeOptions.MergeOptions) +getCherryPickOptionsMergeOptions obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "merge-options" Ggit.MergeOptions.MergeOptions + +{- | +Set the value of the “@merge-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' cherryPickOptions [ #mergeOptions 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCherryPickOptionsMergeOptions :: (MonadIO m, IsCherryPickOptions o) => o -> Ggit.MergeOptions.MergeOptions -> m () +setCherryPickOptionsMergeOptions obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "merge-options" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@merge-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCherryPickOptionsMergeOptions :: (IsCherryPickOptions o) => Ggit.MergeOptions.MergeOptions -> IO (GValueConstruct o) +constructCherryPickOptionsMergeOptions val = B.Properties.constructObjectPropertyBoxed "merge-options" (Just val) + +{- | +Set the value of the “@merge-options@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #mergeOptions +@ +-} +clearCherryPickOptionsMergeOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m () +clearCherryPickOptionsMergeOptions obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "merge-options" (Nothing :: Maybe Ggit.MergeOptions.MergeOptions) + +#if ENABLE_OVERLOADING +data CherryPickOptionsMergeOptionsPropertyInfo +instance AttrInfo CherryPickOptionsMergeOptionsPropertyInfo where + type AttrAllowedOps CherryPickOptionsMergeOptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CherryPickOptionsMergeOptionsPropertyInfo = (~) Ggit.MergeOptions.MergeOptions + type AttrBaseTypeConstraint CherryPickOptionsMergeOptionsPropertyInfo = IsCherryPickOptions + type AttrGetType CherryPickOptionsMergeOptionsPropertyInfo = (Maybe Ggit.MergeOptions.MergeOptions) + type AttrLabel CherryPickOptionsMergeOptionsPropertyInfo = "merge-options" + type AttrOrigin CherryPickOptionsMergeOptionsPropertyInfo = CherryPickOptions + attrGet _ = getCherryPickOptionsMergeOptions + attrSet _ = setCherryPickOptionsMergeOptions + attrConstruct _ = constructCherryPickOptionsMergeOptions + attrClear _ = clearCherryPickOptionsMergeOptions +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CherryPickOptions +type instance O.AttributeList CherryPickOptions = CherryPickOptionsAttributeList +type CherryPickOptionsAttributeList = ('[ '("checkoutOptions", CherryPickOptionsCheckoutOptionsPropertyInfo), '("mainline", CherryPickOptionsMainlinePropertyInfo), '("mergeOptions", CherryPickOptionsMergeOptionsPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +cherryPickOptionsCheckoutOptions :: AttrLabelProxy "checkoutOptions" +cherryPickOptionsCheckoutOptions = AttrLabelProxy + +cherryPickOptionsMainline :: AttrLabelProxy "mainline" +cherryPickOptionsMainline = AttrLabelProxy + +cherryPickOptionsMergeOptions :: AttrLabelProxy "mergeOptions" +cherryPickOptionsMergeOptions = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CherryPickOptions = CherryPickOptionsSignalList +type CherryPickOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CherryPickOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cherry_pick_options_new" ggit_cherry_pick_options_new :: + IO (Ptr CherryPickOptions) + +{- | +Create a new cherry-pick options object. +-} +cherryPickOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m CherryPickOptions + {- ^ __Returns:__ a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} +cherryPickOptionsNew = liftIO $ do + result <- ggit_cherry_pick_options_new + checkUnexpectedReturnNULL "cherryPickOptionsNew" result + result' <- (wrapObject CherryPickOptions) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CherryPickOptions::get_checkout_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCherryPickOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cherry_pick_options_get_checkout_options" ggit_cherry_pick_options_get_checkout_options :: + Ptr CherryPickOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}) + IO (Ptr Ggit.CheckoutOptions.CheckoutOptions) + +{- | +Get the checkout options. +-} +cherryPickOptionsGetCheckoutOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsCherryPickOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} + -> m Ggit.CheckoutOptions.CheckoutOptions + {- ^ __Returns:__ a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} +cherryPickOptionsGetCheckoutOptions options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_cherry_pick_options_get_checkout_options options' + checkUnexpectedReturnNULL "cherryPickOptionsGetCheckoutOptions" result + result' <- (newObject Ggit.CheckoutOptions.CheckoutOptions) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CherryPickOptionsGetCheckoutOptionsMethodInfo +instance (signature ~ (m Ggit.CheckoutOptions.CheckoutOptions), MonadIO m, IsCherryPickOptions a) => O.MethodInfo CherryPickOptionsGetCheckoutOptionsMethodInfo a signature where + overloadedMethod _ = cherryPickOptionsGetCheckoutOptions + +#endif + +-- method CherryPickOptions::get_mainline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCherryPickOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cherry_pick_options_get_mainline" ggit_cherry_pick_options_get_mainline :: + Ptr CherryPickOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}) + IO Word32 + +{- | +Get the mainline parent to use when cherry-picking a merge commit. +-} +cherryPickOptionsGetMainline :: + (B.CallStack.HasCallStack, MonadIO m, IsCherryPickOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} + -> m Word32 + {- ^ __Returns:__ the mainline parent. -} +cherryPickOptionsGetMainline options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_cherry_pick_options_get_mainline options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data CherryPickOptionsGetMainlineMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsCherryPickOptions a) => O.MethodInfo CherryPickOptionsGetMainlineMethodInfo a signature where + overloadedMethod _ = cherryPickOptionsGetMainline + +#endif + +-- method CherryPickOptions::get_merge_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCherryPickOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "MergeOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cherry_pick_options_get_merge_options" ggit_cherry_pick_options_get_merge_options :: + Ptr CherryPickOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}) + IO (Ptr Ggit.MergeOptions.MergeOptions) + +{- | +Get the merge options. +-} +cherryPickOptionsGetMergeOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsCherryPickOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} + -> m Ggit.MergeOptions.MergeOptions + {- ^ __Returns:__ a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} +cherryPickOptionsGetMergeOptions options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_cherry_pick_options_get_merge_options options' + checkUnexpectedReturnNULL "cherryPickOptionsGetMergeOptions" result + result' <- (wrapBoxed Ggit.MergeOptions.MergeOptions) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CherryPickOptionsGetMergeOptionsMethodInfo +instance (signature ~ (m Ggit.MergeOptions.MergeOptions), MonadIO m, IsCherryPickOptions a) => O.MethodInfo CherryPickOptionsGetMergeOptionsMethodInfo a signature where + overloadedMethod _ = cherryPickOptionsGetMergeOptions + +#endif + +-- method CherryPickOptions::set_checkout_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCherryPickOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checkout_options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cherry_pick_options_set_checkout_options" ggit_cherry_pick_options_set_checkout_options :: + Ptr CherryPickOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- checkout_options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO () + +{- | +Set the checkout options. +-} +cherryPickOptionsSetCheckoutOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsCherryPickOptions a, Ggit.CheckoutOptions.IsCheckoutOptions b) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} + -> Maybe (b) + {- ^ /@checkoutOptions@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m () +cherryPickOptionsSetCheckoutOptions options checkoutOptions = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeCheckoutOptions <- case checkoutOptions of + Nothing -> return nullPtr + Just jCheckoutOptions -> do + jCheckoutOptions' <- unsafeManagedPtrCastPtr jCheckoutOptions + return jCheckoutOptions' + ggit_cherry_pick_options_set_checkout_options options' maybeCheckoutOptions + touchManagedPtr options + whenJust checkoutOptions touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CherryPickOptionsSetCheckoutOptionsMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCherryPickOptions a, Ggit.CheckoutOptions.IsCheckoutOptions b) => O.MethodInfo CherryPickOptionsSetCheckoutOptionsMethodInfo a signature where + overloadedMethod _ = cherryPickOptionsSetCheckoutOptions + +#endif + +-- method CherryPickOptions::set_mainline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCherryPickOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mainline", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the mainline parent.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cherry_pick_options_set_mainline" ggit_cherry_pick_options_set_mainline :: + Ptr CherryPickOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}) + Word32 -> -- mainline : TBasicType TUInt + IO () + +{- | +Set the mainline parent to use when cherry-picking a merge commit. +-} +cherryPickOptionsSetMainline :: + (B.CallStack.HasCallStack, MonadIO m, IsCherryPickOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} + -> Word32 + {- ^ /@mainline@/: the mainline parent. -} + -> m () +cherryPickOptionsSetMainline options mainline = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_cherry_pick_options_set_mainline options' mainline + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CherryPickOptionsSetMainlineMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsCherryPickOptions a) => O.MethodInfo CherryPickOptionsSetMainlineMethodInfo a signature where + overloadedMethod _ = cherryPickOptionsSetMainline + +#endif + +-- method CherryPickOptions::set_merge_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCherryPickOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cherry_pick_options_set_merge_options" ggit_cherry_pick_options_set_merge_options :: + Ptr CherryPickOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}) + Ptr Ggit.MergeOptions.MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO () + +{- | +Set the merge options. +-} +cherryPickOptionsSetMergeOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsCherryPickOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} + -> Maybe (Ggit.MergeOptions.MergeOptions) + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m () +cherryPickOptionsSetMergeOptions options mergeOptions = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeMergeOptions <- case mergeOptions of + Nothing -> return nullPtr + Just jMergeOptions -> do + jMergeOptions' <- unsafeManagedPtrGetPtr jMergeOptions + return jMergeOptions' + ggit_cherry_pick_options_set_merge_options options' maybeMergeOptions + touchManagedPtr options + whenJust mergeOptions touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CherryPickOptionsSetMergeOptionsMethodInfo +instance (signature ~ (Maybe (Ggit.MergeOptions.MergeOptions) -> m ()), MonadIO m, IsCherryPickOptions a) => O.MethodInfo CherryPickOptionsSetMergeOptionsMethodInfo a signature where + overloadedMethod _ = cherryPickOptionsSetMergeOptions + +#endif + + diff --git a/GI/Ggit/Objects/CherryPickOptions.hs-boot b/GI/Ggit/Objects/CherryPickOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CherryPickOptions.hs-boot @@ -0,0 +1,56 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.CherryPickOptions 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 + +newtype CherryPickOptions = CherryPickOptions (ManagedPtr CherryPickOptions) +instance GObject CherryPickOptions where +class (GObject o, O.IsDescendantOf CherryPickOptions o) => IsCherryPickOptions o +instance (GObject o, O.IsDescendantOf CherryPickOptions o) => IsCherryPickOptions o +instance O.HasParentTypes CherryPickOptions +#if ENABLE_OVERLOADING +data CherryPickOptionsCheckoutOptionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsMainlinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsMergeOptionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsGetCheckoutOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsGetMainlineMethodInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsGetMergeOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsSetCheckoutOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsSetMainlineMethodInfo +#endif +#if ENABLE_OVERLOADING +data CherryPickOptionsSetMergeOptionsMethodInfo +#endif diff --git a/GI/Ggit/Objects/CloneOptions.hs b/GI/Ggit/Objects/CloneOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CloneOptions.hs @@ -0,0 +1,535 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when cloning. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.CloneOptions + ( + +-- * Exported types + CloneOptions(..) , + IsCloneOptions , + toCloneOptions , + noCloneOptions , + + + -- * Methods +-- ** getCheckoutBranch #method:getCheckoutBranch# + +#if ENABLE_OVERLOADING + CloneOptionsGetCheckoutBranchMethodInfo , +#endif + cloneOptionsGetCheckoutBranch , + + +-- ** getFetchOptions #method:getFetchOptions# + +#if ENABLE_OVERLOADING + CloneOptionsGetFetchOptionsMethodInfo , +#endif + cloneOptionsGetFetchOptions , + + +-- ** getIsBare #method:getIsBare# + +#if ENABLE_OVERLOADING + CloneOptionsGetIsBareMethodInfo , +#endif + cloneOptionsGetIsBare , + + +-- ** getLocal #method:getLocal# + +#if ENABLE_OVERLOADING + CloneOptionsGetLocalMethodInfo , +#endif + cloneOptionsGetLocal , + + +-- ** new #method:new# + + cloneOptionsNew , + + +-- ** setCheckoutBranch #method:setCheckoutBranch# + +#if ENABLE_OVERLOADING + CloneOptionsSetCheckoutBranchMethodInfo , +#endif + cloneOptionsSetCheckoutBranch , + + +-- ** setFetchOptions #method:setFetchOptions# + +#if ENABLE_OVERLOADING + CloneOptionsSetFetchOptionsMethodInfo , +#endif + cloneOptionsSetFetchOptions , + + +-- ** setIsBare #method:setIsBare# + +#if ENABLE_OVERLOADING + CloneOptionsSetIsBareMethodInfo , +#endif + cloneOptionsSetIsBare , + + +-- ** setLocal #method:setLocal# + +#if ENABLE_OVERLOADING + CloneOptionsSetLocalMethodInfo , +#endif + cloneOptionsSetLocal , + + + + + ) 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.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Structs.FetchOptions as Ggit.FetchOptions + +-- | Memory-managed wrapper type. +newtype CloneOptions = CloneOptions (ManagedPtr CloneOptions) +foreign import ccall "ggit_clone_options_get_type" + c_ggit_clone_options_get_type :: IO GType + +instance GObject CloneOptions where + gobjectType = c_ggit_clone_options_get_type + + +-- | Type class for types which can be safely cast to `CloneOptions`, for instance with `toCloneOptions`. +class (GObject o, O.IsDescendantOf CloneOptions o) => IsCloneOptions o +instance (GObject o, O.IsDescendantOf CloneOptions o) => IsCloneOptions o + +instance O.HasParentTypes CloneOptions +type instance O.ParentTypes CloneOptions = '[GObject.Object.Object] + +-- | Cast to `CloneOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCloneOptions :: (MonadIO m, IsCloneOptions o) => o -> m CloneOptions +toCloneOptions = liftIO . unsafeCastTo CloneOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `CloneOptions`. +noCloneOptions :: Maybe CloneOptions +noCloneOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCloneOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveCloneOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCloneOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCloneOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCloneOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCloneOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCloneOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCloneOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCloneOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCloneOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCloneOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCloneOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCloneOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCloneOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCloneOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCloneOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCloneOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCloneOptionsMethod "getCheckoutBranch" o = CloneOptionsGetCheckoutBranchMethodInfo + ResolveCloneOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCloneOptionsMethod "getFetchOptions" o = CloneOptionsGetFetchOptionsMethodInfo + ResolveCloneOptionsMethod "getIsBare" o = CloneOptionsGetIsBareMethodInfo + ResolveCloneOptionsMethod "getLocal" o = CloneOptionsGetLocalMethodInfo + ResolveCloneOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCloneOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCloneOptionsMethod "setCheckoutBranch" o = CloneOptionsSetCheckoutBranchMethodInfo + ResolveCloneOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCloneOptionsMethod "setFetchOptions" o = CloneOptionsSetFetchOptionsMethodInfo + ResolveCloneOptionsMethod "setIsBare" o = CloneOptionsSetIsBareMethodInfo + ResolveCloneOptionsMethod "setLocal" o = CloneOptionsSetLocalMethodInfo + ResolveCloneOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCloneOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCloneOptionsMethod t CloneOptions, O.MethodInfo info CloneOptions p) => OL.IsLabel t (CloneOptions -> 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 CloneOptions +type instance O.AttributeList CloneOptions = CloneOptionsAttributeList +type CloneOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CloneOptions = CloneOptionsSignalList +type CloneOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CloneOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CloneOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_new" ggit_clone_options_new :: + IO (Ptr CloneOptions) + +{- | +Creates a new 'GI.Ggit.Objects.CloneOptions.CloneOptions'. +-} +cloneOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m CloneOptions + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} +cloneOptionsNew = liftIO $ do + result <- ggit_clone_options_new + checkUnexpectedReturnNULL "cloneOptionsNew" result + result' <- (wrapObject CloneOptions) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CloneOptions::get_checkout_branch +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_get_checkout_branch" ggit_clone_options_get_checkout_branch :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + IO CString + +{- | +Gets the name of the branch to checkout or 'Nothing'. +-} +cloneOptionsGetCheckoutBranch :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> m T.Text + {- ^ __Returns:__ the name of the branch to checkout or 'Nothing'. -} +cloneOptionsGetCheckoutBranch options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_clone_options_get_checkout_branch options' + checkUnexpectedReturnNULL "cloneOptionsGetCheckoutBranch" result + result' <- cstringToText result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CloneOptionsGetCheckoutBranchMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsGetCheckoutBranchMethodInfo a signature where + overloadedMethod _ = cloneOptionsGetCheckoutBranch + +#endif + +-- method CloneOptions::get_fetch_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "FetchOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_get_fetch_options" ggit_clone_options_get_fetch_options :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + IO (Ptr Ggit.FetchOptions.FetchOptions) + +{- | +Get the fetch options object or 'Nothing' if not set. +-} +cloneOptionsGetFetchOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> m Ggit.FetchOptions.FetchOptions + {- ^ __Returns:__ the fetch options or 'Nothing'. -} +cloneOptionsGetFetchOptions options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_clone_options_get_fetch_options options' + checkUnexpectedReturnNULL "cloneOptionsGetFetchOptions" result + result' <- (newBoxed Ggit.FetchOptions.FetchOptions) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CloneOptionsGetFetchOptionsMethodInfo +instance (signature ~ (m Ggit.FetchOptions.FetchOptions), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsGetFetchOptionsMethodInfo a signature where + overloadedMethod _ = cloneOptionsGetFetchOptions + +#endif + +-- method CloneOptions::get_is_bare +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_get_is_bare" ggit_clone_options_get_is_bare :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + IO CInt + +{- | +Gets if the repository will be bare. +-} +cloneOptionsGetIsBare :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> m Bool + {- ^ __Returns:__ 'True' to clone a bare repository. -} +cloneOptionsGetIsBare options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_clone_options_get_is_bare options' + let result' = (/= 0) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CloneOptionsGetIsBareMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsGetIsBareMethodInfo a signature where + overloadedMethod _ = cloneOptionsGetIsBare + +#endif + +-- method CloneOptions::get_local +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CloneLocal"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_get_local" ggit_clone_options_get_local :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + IO CUInt + +{- | +Get setting for bypassing the git-aware transport when cloning. The +default auto setting bypasses the git-aware transport for local paths, +but use a normal fetch for file:\/\/ URIs. +-} +cloneOptionsGetLocal :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> m Ggit.Enums.CloneLocal + {- ^ __Returns:__ the local clone setting. -} +cloneOptionsGetLocal options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_clone_options_get_local options' + let result' = (toEnum . fromIntegral) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data CloneOptionsGetLocalMethodInfo +instance (signature ~ (m Ggit.Enums.CloneLocal), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsGetLocalMethodInfo a signature where + overloadedMethod _ = cloneOptionsGetLocal + +#endif + +-- method CloneOptions::set_checkout_branch +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checkout_branch", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the branch to checkout or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_set_checkout_branch" ggit_clone_options_set_checkout_branch :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + CString -> -- checkout_branch : TBasicType TUTF8 + IO () + +{- | +Gives the name of the branch to checkout. 'Nothing' means +use the remote\'s HEAD. +-} +cloneOptionsSetCheckoutBranch :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> Maybe (T.Text) + {- ^ /@checkoutBranch@/: the name of the branch to checkout or 'Nothing'. -} + -> m () +cloneOptionsSetCheckoutBranch options checkoutBranch = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeCheckoutBranch <- case checkoutBranch of + Nothing -> return nullPtr + Just jCheckoutBranch -> do + jCheckoutBranch' <- textToCString jCheckoutBranch + return jCheckoutBranch' + ggit_clone_options_set_checkout_branch options' maybeCheckoutBranch + touchManagedPtr options + freeMem maybeCheckoutBranch + return () + +#if ENABLE_OVERLOADING +data CloneOptionsSetCheckoutBranchMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsSetCheckoutBranchMethodInfo a signature where + overloadedMethod _ = cloneOptionsSetCheckoutBranch + +#endif + +-- method CloneOptions::set_fetch_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fetch_options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_set_fetch_options" ggit_clone_options_set_fetch_options :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + Ptr Ggit.FetchOptions.FetchOptions -> -- fetch_options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + IO () + +{- | +Set the fetch options object. +-} +cloneOptionsSetFetchOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> Maybe (Ggit.FetchOptions.FetchOptions) + {- ^ /@fetchOptions@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions' or 'Nothing'. -} + -> m () +cloneOptionsSetFetchOptions options fetchOptions = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeFetchOptions <- case fetchOptions of + Nothing -> return nullPtr + Just jFetchOptions -> do + jFetchOptions' <- unsafeManagedPtrGetPtr jFetchOptions + return jFetchOptions' + ggit_clone_options_set_fetch_options options' maybeFetchOptions + touchManagedPtr options + whenJust fetchOptions touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CloneOptionsSetFetchOptionsMethodInfo +instance (signature ~ (Maybe (Ggit.FetchOptions.FetchOptions) -> m ()), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsSetFetchOptionsMethodInfo a signature where + overloadedMethod _ = cloneOptionsSetFetchOptions + +#endif + +-- method CloneOptions::set_is_bare +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bare", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to clone a bare repository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_set_is_bare" ggit_clone_options_set_is_bare :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + CInt -> -- bare : TBasicType TBoolean + IO () + +{- | +Sets whether to clone a bare repository. +-} +cloneOptionsSetIsBare :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> Bool + {- ^ /@bare@/: 'True' to clone a bare repository. -} + -> m () +cloneOptionsSetIsBare options bare = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let bare' = (fromIntegral . fromEnum) bare + ggit_clone_options_set_is_bare options' bare' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CloneOptionsSetIsBareMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsSetIsBareMethodInfo a signature where + overloadedMethod _ = cloneOptionsSetIsBare + +#endif + +-- method CloneOptions::set_local +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "local", argType = TInterface (Name {namespace = "Ggit", name = "CloneLocal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the local clone setting.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_clone_options_set_local" ggit_clone_options_set_local :: + Ptr CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + CUInt -> -- local : TInterface (Name {namespace = "Ggit", name = "CloneLocal"}) + IO () + +{- | +Set setting for bypassing the git-aware transport when cloning. The +default auto setting bypasses the git-aware transport for local paths, +but use a normal fetch for file:\/\/ URIs. +-} +cloneOptionsSetLocal :: + (B.CallStack.HasCallStack, MonadIO m, IsCloneOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> Ggit.Enums.CloneLocal + {- ^ /@local@/: the local clone setting. -} + -> m () +cloneOptionsSetLocal options local = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let local' = (fromIntegral . fromEnum) local + ggit_clone_options_set_local options' local' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data CloneOptionsSetLocalMethodInfo +instance (signature ~ (Ggit.Enums.CloneLocal -> m ()), MonadIO m, IsCloneOptions a) => O.MethodInfo CloneOptionsSetLocalMethodInfo a signature where + overloadedMethod _ = cloneOptionsSetLocal + +#endif + + diff --git a/GI/Ggit/Objects/CloneOptions.hs-boot b/GI/Ggit/Objects/CloneOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CloneOptions.hs-boot @@ -0,0 +1,53 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.CloneOptions 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 + +newtype CloneOptions = CloneOptions (ManagedPtr CloneOptions) +instance GObject CloneOptions where +class (GObject o, O.IsDescendantOf CloneOptions o) => IsCloneOptions o +instance (GObject o, O.IsDescendantOf CloneOptions o) => IsCloneOptions o +instance O.HasParentTypes CloneOptions +#if ENABLE_OVERLOADING +data CloneOptionsGetCheckoutBranchMethodInfo +#endif +#if ENABLE_OVERLOADING +data CloneOptionsGetFetchOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CloneOptionsGetIsBareMethodInfo +#endif +#if ENABLE_OVERLOADING +data CloneOptionsGetLocalMethodInfo +#endif +#if ENABLE_OVERLOADING +data CloneOptionsSetCheckoutBranchMethodInfo +#endif +#if ENABLE_OVERLOADING +data CloneOptionsSetFetchOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CloneOptionsSetIsBareMethodInfo +#endif +#if ENABLE_OVERLOADING +data CloneOptionsSetLocalMethodInfo +#endif diff --git a/GI/Ggit/Objects/Commit.hs b/GI/Ggit/Objects/Commit.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Commit.hs @@ -0,0 +1,666 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a commit object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Commit + ( + +-- * Exported types + Commit(..) , + IsCommit , + toCommit , + noCommit , + + + -- * Methods +-- ** amend #method:amend# + +#if ENABLE_OVERLOADING + CommitAmendMethodInfo , +#endif + commitAmend , + + +-- ** getAuthor #method:getAuthor# + +#if ENABLE_OVERLOADING + CommitGetAuthorMethodInfo , +#endif + commitGetAuthor , + + +-- ** getCommitter #method:getCommitter# + +#if ENABLE_OVERLOADING + CommitGetCommitterMethodInfo , +#endif + commitGetCommitter , + + +-- ** getMessage #method:getMessage# + +#if ENABLE_OVERLOADING + CommitGetMessageMethodInfo , +#endif + commitGetMessage , + + +-- ** getMessageEncoding #method:getMessageEncoding# + +#if ENABLE_OVERLOADING + CommitGetMessageEncodingMethodInfo , +#endif + commitGetMessageEncoding , + + +-- ** getNthAncestor #method:getNthAncestor# + +#if ENABLE_OVERLOADING + CommitGetNthAncestorMethodInfo , +#endif + commitGetNthAncestor , + + +-- ** getParents #method:getParents# + +#if ENABLE_OVERLOADING + CommitGetParentsMethodInfo , +#endif + commitGetParents , + + +-- ** getSubject #method:getSubject# + +#if ENABLE_OVERLOADING + CommitGetSubjectMethodInfo , +#endif + commitGetSubject , + + +-- ** getTree #method:getTree# + +#if ENABLE_OVERLOADING + CommitGetTreeMethodInfo , +#endif + commitGetTree , + + +-- ** getTreeId #method:getTreeId# + +#if ENABLE_OVERLOADING + CommitGetTreeIdMethodInfo , +#endif + commitGetTreeId , + + + + + ) 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.Objects.CommitParents as Ggit.CommitParents +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Objects.Tree as Ggit.Tree +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype Commit = Commit (ManagedPtr Commit) +foreign import ccall "ggit_commit_get_type" + c_ggit_commit_get_type :: IO GType + +instance GObject Commit where + gobjectType = c_ggit_commit_get_type + + +-- | Type class for types which can be safely cast to `Commit`, for instance with `toCommit`. +class (GObject o, O.IsDescendantOf Commit o) => IsCommit o +instance (GObject o, O.IsDescendantOf Commit o) => IsCommit o + +instance O.HasParentTypes Commit +type instance O.ParentTypes Commit = '[Ggit.Object.Object, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Commit`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCommit :: (MonadIO m, IsCommit o) => o -> m Commit +toCommit = liftIO . unsafeCastTo Commit + +-- | A convenience alias for `Nothing` :: `Maybe` `Commit`. +noCommit :: Maybe Commit +noCommit = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCommitMethod (t :: Symbol) (o :: *) :: * where + ResolveCommitMethod "amend" o = CommitAmendMethodInfo + ResolveCommitMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCommitMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCommitMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCommitMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCommitMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCommitMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCommitMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCommitMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCommitMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCommitMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCommitMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCommitMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCommitMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCommitMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCommitMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCommitMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCommitMethod "getAuthor" o = CommitGetAuthorMethodInfo + ResolveCommitMethod "getCommitter" o = CommitGetCommitterMethodInfo + ResolveCommitMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCommitMethod "getId" o = Ggit.Object.ObjectGetIdMethodInfo + ResolveCommitMethod "getMessage" o = CommitGetMessageMethodInfo + ResolveCommitMethod "getMessageEncoding" o = CommitGetMessageEncodingMethodInfo + ResolveCommitMethod "getNthAncestor" o = CommitGetNthAncestorMethodInfo + ResolveCommitMethod "getOwner" o = Ggit.Object.ObjectGetOwnerMethodInfo + ResolveCommitMethod "getParents" o = CommitGetParentsMethodInfo + ResolveCommitMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCommitMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCommitMethod "getSubject" o = CommitGetSubjectMethodInfo + ResolveCommitMethod "getTree" o = CommitGetTreeMethodInfo + ResolveCommitMethod "getTreeId" o = CommitGetTreeIdMethodInfo + ResolveCommitMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCommitMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCommitMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCommitMethod t Commit, O.MethodInfo info Commit p) => OL.IsLabel t (Commit -> 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 Commit +type instance O.AttributeList Commit = CommitAttributeList +type CommitAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Commit = CommitSignalList +type CommitSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Commit::amend +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "name of the reference to update.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "author signature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "committer signature (and time of commit).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message_encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "message encoding.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "commit message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tree of objects to commit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_commit_amend" ggit_commit_amend :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + CString -> -- update_ref : TBasicType TUTF8 + Ptr Ggit.Signature.Signature -> -- author : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.Signature.Signature -> -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message_encoding : TBasicType TUTF8 + CString -> -- message : TBasicType TUTF8 + Ptr Ggit.Tree.Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Amend an existing commit. If /@updateRef@/ is not 'Nothing', the given reference will +be updated to point to the newly created commit. Use \"HEAD\" to update the +HEAD of the current branch and make it point to this commit. + +If /@messageEncoding@/ is set to 'Nothing', \"UTF-8\" encoding is assumed for the +provided /@message@/. Note that /@message@/ will not be cleaned up automatically. +You can use @/ggit_message_prettify/@ to do this yourself if needed. +-} +commitAmend :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c, Ggit.Tree.IsTree d) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> Maybe (T.Text) + {- ^ /@updateRef@/: name of the reference to update. -} + -> b + {- ^ /@author@/: author signature. -} + -> c + {- ^ /@committer@/: committer signature (and time of commit). -} + -> Maybe (T.Text) + {- ^ /@messageEncoding@/: message encoding. -} + -> T.Text + {- ^ /@message@/: commit message. -} + -> d + {- ^ /@tree@/: the tree of objects to commit. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the 'GI.Ggit.Structs.OId.OId' of the created commit object, +or 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +commitAmend commit updateRef author committer messageEncoding message tree = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + maybeUpdateRef <- case updateRef of + Nothing -> return nullPtr + Just jUpdateRef -> do + jUpdateRef' <- textToCString jUpdateRef + return jUpdateRef' + author' <- unsafeManagedPtrCastPtr author + committer' <- unsafeManagedPtrCastPtr committer + maybeMessageEncoding <- case messageEncoding of + Nothing -> return nullPtr + Just jMessageEncoding -> do + jMessageEncoding' <- textToCString jMessageEncoding + return jMessageEncoding' + message' <- textToCString message + tree' <- unsafeManagedPtrCastPtr tree + onException (do + result <- propagateGError $ ggit_commit_amend commit' maybeUpdateRef author' committer' maybeMessageEncoding message' tree' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr commit + touchManagedPtr author + touchManagedPtr committer + touchManagedPtr tree + freeMem maybeUpdateRef + freeMem maybeMessageEncoding + freeMem message' + return maybeResult + ) (do + freeMem maybeUpdateRef + freeMem maybeMessageEncoding + freeMem message' + ) + +#if ENABLE_OVERLOADING +data CommitAmendMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> c -> Maybe (T.Text) -> T.Text -> d -> m (Maybe Ggit.OId.OId)), MonadIO m, IsCommit a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c, Ggit.Tree.IsTree d) => O.MethodInfo CommitAmendMethodInfo a signature where + overloadedMethod _ = commitAmend + +#endif + +-- method Commit::get_author +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_author" ggit_commit_get_author :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO (Ptr Ggit.Signature.Signature) + +{- | +Gets the author of /@commit@/. The returned value must be free\'d with +'GI.GObject.Objects.Object.objectUnref'. +-} +commitGetAuthor :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe Ggit.Signature.Signature) + {- ^ __Returns:__ the author of the commit. -} +commitGetAuthor commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_author commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Signature.Signature) result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetAuthorMethodInfo +instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetAuthorMethodInfo a signature where + overloadedMethod _ = commitGetAuthor + +#endif + +-- method Commit::get_committer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_committer" ggit_commit_get_committer :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO (Ptr Ggit.Signature.Signature) + +{- | +Gets the committer of /@commit@/. The returned value must be free\'d with +'GI.GObject.Objects.Object.objectUnref'. +-} +commitGetCommitter :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe Ggit.Signature.Signature) + {- ^ __Returns:__ the committer of the commit. -} +commitGetCommitter commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_committer commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Signature.Signature) result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetCommitterMethodInfo +instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetCommitterMethodInfo a signature where + overloadedMethod _ = commitGetCommitter + +#endif + +-- method Commit::get_message +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_message" ggit_commit_get_message :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO CString + +{- | +Gets the full message of /@commit@/. The resulting message is always encoded +in UTF-8. +-} +commitGetMessage :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the message of the commit. -} +commitGetMessage commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_message commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetMessageMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetMessageMethodInfo a signature where + overloadedMethod _ = commitGetMessage + +#endif + +-- method Commit::get_message_encoding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_message_encoding" ggit_commit_get_message_encoding :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO CString + +{- | +Get the encoding for the message of a commit, +as a string representing a standard encoding name. + +The encoding may be 'Nothing' if the \'encoding\' header +in the commit is missing; in that case UTF-8 is assumed. +-} +commitGetMessageEncoding :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the encoding of the commit message or 'Nothing'. -} +commitGetMessageEncoding commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_message_encoding commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetMessageEncodingMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetMessageEncodingMethodInfo a signature where + overloadedMethod _ = commitGetMessageEncoding + +#endif + +-- method Commit::get_nth_ancestor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the requested ancestor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Commit"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_commit_get_nth_ancestor" ggit_commit_get_nth_ancestor :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + Word32 -> -- n : TBasicType TUInt + Ptr (Ptr GError) -> -- error + IO (Ptr Commit) + +{- | +Gets the commit object that is the n-th generation ancestor +of the named commit object, following only the first parents. +Passing @/0/@ to the /@n@/ parameter returns another instance of /@commit@/. +-} +commitGetNthAncestor :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> Word32 + {- ^ /@n@/: the requested ancestor. -} + -> m (Maybe Commit) + {- ^ __Returns:__ the /@n@/ ancestor commit. /(Can throw 'Data.GI.Base.GError.GError')/ -} +commitGetNthAncestor commit n = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + onException (do + result <- propagateGError $ ggit_commit_get_nth_ancestor commit' n + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Commit) result' + return result'' + touchManagedPtr commit + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CommitGetNthAncestorMethodInfo +instance (signature ~ (Word32 -> m (Maybe Commit)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetNthAncestorMethodInfo a signature where + overloadedMethod _ = commitGetNthAncestor + +#endif + +-- method Commit::get_parents +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CommitParents"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_parents" ggit_commit_get_parents :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO (Ptr Ggit.CommitParents.CommitParents) + +{- | +Gets the parents collection for /@commit@/. +-} +commitGetParents :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe Ggit.CommitParents.CommitParents) + {- ^ __Returns:__ the parents collection of the commit. -} +commitGetParents commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_parents commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.CommitParents.CommitParents) result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetParentsMethodInfo +instance (signature ~ (m (Maybe Ggit.CommitParents.CommitParents)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetParentsMethodInfo a signature where + overloadedMethod _ = commitGetParents + +#endif + +-- method Commit::get_subject +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_subject" ggit_commit_get_subject :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO CString + +{- | +Gets the subject of /@commit@/. The subject of a commit is the first line of +the commit message (as per convention). The resulting subject is always +encoded in UTF-8. +-} +commitGetSubject :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the subject of the commit. -} +commitGetSubject commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_subject commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetSubjectMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetSubjectMethodInfo a signature where + overloadedMethod _ = commitGetSubject + +#endif + +-- method Commit::get_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Tree"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_tree" ggit_commit_get_tree :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO (Ptr Ggit.Tree.Tree) + +{- | +Get the tree object for /@commit@/. +-} +commitGetTree :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe Ggit.Tree.Tree) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Tree.Tree'. -} +commitGetTree commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_tree commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Tree.Tree) result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetTreeMethodInfo +instance (signature ~ (m (Maybe Ggit.Tree.Tree)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetTreeMethodInfo a signature where + overloadedMethod _ = commitGetTree + +#endif + +-- method Commit::get_tree_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_get_tree_id" ggit_commit_get_tree_id :: + Ptr Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the 'GI.Ggit.Structs.OId.OId' of the tree of /@commit@/. Note that this is more efficient +than getting the tree object with 'GI.Ggit.Objects.Commit.commitGetTree' because no additional +files need to be read from disk. +-} +commitGetTreeId :: + (B.CallStack.HasCallStack, MonadIO m, IsCommit a) => + a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId'. -} +commitGetTreeId commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_get_tree_id commit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr commit + return maybeResult + +#if ENABLE_OVERLOADING +data CommitGetTreeIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetTreeIdMethodInfo a signature where + overloadedMethod _ = commitGetTreeId + +#endif + + diff --git a/GI/Ggit/Objects/Commit.hs-boot b/GI/Ggit/Objects/Commit.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Commit.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Commit 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 + +newtype Commit = Commit (ManagedPtr Commit) +instance GObject Commit where +class (GObject o, O.IsDescendantOf Commit o) => IsCommit o +instance (GObject o, O.IsDescendantOf Commit o) => IsCommit o +instance O.HasParentTypes Commit +#if ENABLE_OVERLOADING +data CommitAmendMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetAuthorMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetCommitterMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetMessageMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetMessageEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetNthAncestorMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetParentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetSubjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitGetTreeIdMethodInfo +#endif diff --git a/GI/Ggit/Objects/CommitParents.hs b/GI/Ggit/Objects/CommitParents.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CommitParents.hs @@ -0,0 +1,404 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the parents of a commit object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.CommitParents + ( + +-- * Exported types + CommitParents(..) , + IsCommitParents , + toCommitParents , + noCommitParents , + + + -- * Methods +-- ** get #method:get# + +#if ENABLE_OVERLOADING + CommitParentsGetMethodInfo , +#endif + commitParentsGet , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + CommitParentsGetIdMethodInfo , +#endif + commitParentsGetId , + + +-- ** getSize #method:getSize# + +#if ENABLE_OVERLOADING + CommitParentsGetSizeMethodInfo , +#endif + commitParentsGetSize , + + +-- ** new #method:new# + + commitParentsNew , + + + + + -- * Properties +-- ** commit #attr:commit# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CommitParentsCommitPropertyInfo , +#endif +#if ENABLE_OVERLOADING + commitParentsCommit , +#endif + constructCommitParentsCommit , + getCommitParentsCommit , + + +-- ** size #attr:size# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CommitParentsSizePropertyInfo , +#endif +#if ENABLE_OVERLOADING + commitParentsSize , +#endif + getCommitParentsSize , + + + + + ) 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.Objects.Commit as Ggit.Commit +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype CommitParents = CommitParents (ManagedPtr CommitParents) +foreign import ccall "ggit_commit_parents_get_type" + c_ggit_commit_parents_get_type :: IO GType + +instance GObject CommitParents where + gobjectType = c_ggit_commit_parents_get_type + + +-- | Type class for types which can be safely cast to `CommitParents`, for instance with `toCommitParents`. +class (GObject o, O.IsDescendantOf CommitParents o) => IsCommitParents o +instance (GObject o, O.IsDescendantOf CommitParents o) => IsCommitParents o + +instance O.HasParentTypes CommitParents +type instance O.ParentTypes CommitParents = '[GObject.Object.Object] + +-- | Cast to `CommitParents`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCommitParents :: (MonadIO m, IsCommitParents o) => o -> m CommitParents +toCommitParents = liftIO . unsafeCastTo CommitParents + +-- | A convenience alias for `Nothing` :: `Maybe` `CommitParents`. +noCommitParents :: Maybe CommitParents +noCommitParents = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCommitParentsMethod (t :: Symbol) (o :: *) :: * where + ResolveCommitParentsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCommitParentsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCommitParentsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCommitParentsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCommitParentsMethod "get" o = CommitParentsGetMethodInfo + ResolveCommitParentsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCommitParentsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCommitParentsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCommitParentsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCommitParentsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCommitParentsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCommitParentsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCommitParentsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCommitParentsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCommitParentsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCommitParentsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCommitParentsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCommitParentsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCommitParentsMethod "getId" o = CommitParentsGetIdMethodInfo + ResolveCommitParentsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCommitParentsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCommitParentsMethod "getSize" o = CommitParentsGetSizeMethodInfo + ResolveCommitParentsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCommitParentsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCommitParentsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCommitParentsMethod t CommitParents, O.MethodInfo info CommitParents p) => OL.IsLabel t (CommitParents -> 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 + +-- VVV Prop "commit" + -- Type: TInterface (Name {namespace = "Ggit", name = "Commit"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@commit@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' commitParents #commit +@ +-} +getCommitParentsCommit :: (MonadIO m, IsCommitParents o) => o -> m (Maybe Ggit.Commit.Commit) +getCommitParentsCommit obj = liftIO $ B.Properties.getObjectPropertyObject obj "commit" Ggit.Commit.Commit + +{- | +Construct a `GValueConstruct` with valid value for the “@commit@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCommitParentsCommit :: (IsCommitParents o, Ggit.Commit.IsCommit a) => a -> IO (GValueConstruct o) +constructCommitParentsCommit val = B.Properties.constructObjectPropertyObject "commit" (Just val) + +#if ENABLE_OVERLOADING +data CommitParentsCommitPropertyInfo +instance AttrInfo CommitParentsCommitPropertyInfo where + type AttrAllowedOps CommitParentsCommitPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CommitParentsCommitPropertyInfo = Ggit.Commit.IsCommit + type AttrBaseTypeConstraint CommitParentsCommitPropertyInfo = IsCommitParents + type AttrGetType CommitParentsCommitPropertyInfo = (Maybe Ggit.Commit.Commit) + type AttrLabel CommitParentsCommitPropertyInfo = "commit" + type AttrOrigin CommitParentsCommitPropertyInfo = CommitParents + attrGet _ = getCommitParentsCommit + attrSet _ = undefined + attrConstruct _ = constructCommitParentsCommit + attrClear _ = undefined +#endif + +-- VVV Prop "size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' commitParents #size +@ +-} +getCommitParentsSize :: (MonadIO m, IsCommitParents o) => o -> m Word32 +getCommitParentsSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "size" + +#if ENABLE_OVERLOADING +data CommitParentsSizePropertyInfo +instance AttrInfo CommitParentsSizePropertyInfo where + type AttrAllowedOps CommitParentsSizePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint CommitParentsSizePropertyInfo = (~) () + type AttrBaseTypeConstraint CommitParentsSizePropertyInfo = IsCommitParents + type AttrGetType CommitParentsSizePropertyInfo = Word32 + type AttrLabel CommitParentsSizePropertyInfo = "size" + type AttrOrigin CommitParentsSizePropertyInfo = CommitParents + attrGet _ = getCommitParentsSize + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CommitParents +type instance O.AttributeList CommitParents = CommitParentsAttributeList +type CommitParentsAttributeList = ('[ '("commit", CommitParentsCommitPropertyInfo), '("size", CommitParentsSizePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +commitParentsCommit :: AttrLabelProxy "commit" +commitParentsCommit = AttrLabelProxy + +commitParentsSize :: AttrLabelProxy "size" +commitParentsSize = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CommitParents = CommitParentsSignalList +type CommitParentsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CommitParents::new +-- method type : Constructor +-- Args : [Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CommitParents"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_parents_new" ggit_commit_parents_new :: + Ptr Ggit.Commit.Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO (Ptr CommitParents) + +{- | +/No description available in the introspection data./ +-} +commitParentsNew :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Commit.IsCommit a) => + a + -> m CommitParents +commitParentsNew commit = liftIO $ do + commit' <- unsafeManagedPtrCastPtr commit + result <- ggit_commit_parents_new commit' + checkUnexpectedReturnNULL "commitParentsNew" result + result' <- (wrapObject CommitParents) result + touchManagedPtr commit + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CommitParents::get +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parents", argType = TInterface (Name {namespace = "Ggit", name = "CommitParents"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommitParents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the parent index.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Commit"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_parents_get" ggit_commit_parents_get :: + Ptr CommitParents -> -- parents : TInterface (Name {namespace = "Ggit", name = "CommitParents"}) + Word32 -> -- idx : TBasicType TUInt + IO (Ptr Ggit.Commit.Commit) + +{- | +Get the 'GI.Ggit.Objects.Commit.Commit' of a parent. +-} +commitParentsGet :: + (B.CallStack.HasCallStack, MonadIO m, IsCommitParents a) => + a + {- ^ /@parents@/: a 'GI.Ggit.Objects.CommitParents.CommitParents'. -} + -> Word32 + {- ^ /@idx@/: the parent index. -} + -> m (Maybe Ggit.Commit.Commit) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Commit.Commit'. -} +commitParentsGet parents idx = liftIO $ do + parents' <- unsafeManagedPtrCastPtr parents + result <- ggit_commit_parents_get parents' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Commit.Commit) result' + return result'' + touchManagedPtr parents + return maybeResult + +#if ENABLE_OVERLOADING +data CommitParentsGetMethodInfo +instance (signature ~ (Word32 -> m (Maybe Ggit.Commit.Commit)), MonadIO m, IsCommitParents a) => O.MethodInfo CommitParentsGetMethodInfo a signature where + overloadedMethod _ = commitParentsGet + +#endif + +-- method CommitParents::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parents", argType = TInterface (Name {namespace = "Ggit", name = "CommitParents"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommitParents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the parent index.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_parents_get_id" ggit_commit_parents_get_id :: + Ptr CommitParents -> -- parents : TInterface (Name {namespace = "Ggit", name = "CommitParents"}) + Word32 -> -- idx : TBasicType TUInt + IO (Ptr Ggit.OId.OId) + +{- | +Get the 'GI.Ggit.Structs.OId.OId' of a parent. +-} +commitParentsGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsCommitParents a) => + a + {- ^ /@parents@/: a 'GI.Ggit.Objects.CommitParents.CommitParents'. -} + -> Word32 + {- ^ /@idx@/: the parent index. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId'. -} +commitParentsGetId parents idx = liftIO $ do + parents' <- unsafeManagedPtrCastPtr parents + result <- ggit_commit_parents_get_id parents' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr parents + return maybeResult + +#if ENABLE_OVERLOADING +data CommitParentsGetIdMethodInfo +instance (signature ~ (Word32 -> m (Maybe Ggit.OId.OId)), MonadIO m, IsCommitParents a) => O.MethodInfo CommitParentsGetIdMethodInfo a signature where + overloadedMethod _ = commitParentsGetId + +#endif + +-- method CommitParents::get_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parents", argType = TInterface (Name {namespace = "Ggit", name = "CommitParents"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommitParents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_commit_parents_get_size" ggit_commit_parents_get_size :: + Ptr CommitParents -> -- parents : TInterface (Name {namespace = "Ggit", name = "CommitParents"}) + IO Word32 + +{- | +Get the number of parents in the parents collection. +-} +commitParentsGetSize :: + (B.CallStack.HasCallStack, MonadIO m, IsCommitParents a) => + a + {- ^ /@parents@/: a 'GI.Ggit.Objects.CommitParents.CommitParents'. -} + -> m Word32 + {- ^ __Returns:__ the number of parents. -} +commitParentsGetSize parents = liftIO $ do + parents' <- unsafeManagedPtrCastPtr parents + result <- ggit_commit_parents_get_size parents' + touchManagedPtr parents + return result + +#if ENABLE_OVERLOADING +data CommitParentsGetSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsCommitParents a) => O.MethodInfo CommitParentsGetSizeMethodInfo a signature where + overloadedMethod _ = commitParentsGetSize + +#endif + + diff --git a/GI/Ggit/Objects/CommitParents.hs-boot b/GI/Ggit/Objects/CommitParents.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CommitParents.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.CommitParents 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 + +newtype CommitParents = CommitParents (ManagedPtr CommitParents) +instance GObject CommitParents where +class (GObject o, O.IsDescendantOf CommitParents o) => IsCommitParents o +instance (GObject o, O.IsDescendantOf CommitParents o) => IsCommitParents o +instance O.HasParentTypes CommitParents +#if ENABLE_OVERLOADING +data CommitParentsCommitPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CommitParentsSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CommitParentsGetMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitParentsGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data CommitParentsGetSizeMethodInfo +#endif diff --git a/GI/Ggit/Objects/Config.hs b/GI/Ggit/Objects/Config.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Config.hs @@ -0,0 +1,1236 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git configuration. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Config + ( + +-- * Exported types + Config(..) , + IsConfig , + toConfig , + noConfig , + + + -- * Methods +-- ** addFile #method:addFile# + +#if ENABLE_OVERLOADING + ConfigAddFileMethodInfo , +#endif + configAddFile , + + +-- ** deleteEntry #method:deleteEntry# + +#if ENABLE_OVERLOADING + ConfigDeleteEntryMethodInfo , +#endif + configDeleteEntry , + + +-- ** findGlobal #method:findGlobal# + + configFindGlobal , + + +-- ** findSystem #method:findSystem# + + configFindSystem , + + +-- ** foreach #method:foreach# + +#if ENABLE_OVERLOADING + ConfigForeachMethodInfo , +#endif + configForeach , + + +-- ** getBool #method:getBool# + +#if ENABLE_OVERLOADING + ConfigGetBoolMethodInfo , +#endif + configGetBool , + + +-- ** getEntry #method:getEntry# + +#if ENABLE_OVERLOADING + ConfigGetEntryMethodInfo , +#endif + configGetEntry , + + +-- ** getInt32 #method:getInt32# + +#if ENABLE_OVERLOADING + ConfigGetInt32MethodInfo , +#endif + configGetInt32 , + + +-- ** getInt64 #method:getInt64# + +#if ENABLE_OVERLOADING + ConfigGetInt64MethodInfo , +#endif + configGetInt64 , + + +-- ** getString #method:getString# + +#if ENABLE_OVERLOADING + ConfigGetStringMethodInfo , +#endif + configGetString , + + +-- ** match #method:match# + +#if ENABLE_OVERLOADING + ConfigMatchMethodInfo , +#endif + configMatch , + + +-- ** matchForeach #method:matchForeach# + +#if ENABLE_OVERLOADING + ConfigMatchForeachMethodInfo , +#endif + configMatchForeach , + + +-- ** new #method:new# + + configNew , + + +-- ** newDefault #method:newDefault# + + configNewDefault , + + +-- ** newFromFile #method:newFromFile# + + configNewFromFile , + + +-- ** openLevel #method:openLevel# + +#if ENABLE_OVERLOADING + ConfigOpenLevelMethodInfo , +#endif + configOpenLevel , + + +-- ** setBool #method:setBool# + +#if ENABLE_OVERLOADING + ConfigSetBoolMethodInfo , +#endif + configSetBool , + + +-- ** setInt32 #method:setInt32# + +#if ENABLE_OVERLOADING + ConfigSetInt32MethodInfo , +#endif + configSetInt32 , + + +-- ** setInt64 #method:setInt64# + +#if ENABLE_OVERLOADING + ConfigSetInt64MethodInfo , +#endif + configSetInt64 , + + +-- ** setString #method:setString# + +#if ENABLE_OVERLOADING + ConfigSetStringMethodInfo , +#endif + configSetString , + + +-- ** snapshot #method:snapshot# + +#if ENABLE_OVERLOADING + ConfigSnapshotMethodInfo , +#endif + configSnapshot , + + + + + ) 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.GLib.Structs.MatchInfo as GLib.MatchInfo +import qualified GI.GLib.Structs.Regex as GLib.Regex +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Ggit.Callbacks as Ggit.Callbacks +import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +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.ConfigEntry as Ggit.ConfigEntry +import qualified GI.Gio.Interfaces.File as Gio.File + +-- | Memory-managed wrapper type. +newtype Config = Config (ManagedPtr Config) +foreign import ccall "ggit_config_get_type" + c_ggit_config_get_type :: IO GType + +instance GObject Config where + gobjectType = c_ggit_config_get_type + + +-- | Type class for types which can be safely cast to `Config`, for instance with `toConfig`. +class (GObject o, O.IsDescendantOf Config o) => IsConfig o +instance (GObject o, O.IsDescendantOf Config o) => IsConfig o + +instance O.HasParentTypes Config +type instance O.ParentTypes Config = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Config`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toConfig :: (MonadIO m, IsConfig o) => o -> m Config +toConfig = liftIO . unsafeCastTo Config + +-- | A convenience alias for `Nothing` :: `Maybe` `Config`. +noConfig :: Maybe Config +noConfig = Nothing + +#if ENABLE_OVERLOADING +type family ResolveConfigMethod (t :: Symbol) (o :: *) :: * where + ResolveConfigMethod "addFile" o = ConfigAddFileMethodInfo + ResolveConfigMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveConfigMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveConfigMethod "deleteEntry" o = ConfigDeleteEntryMethodInfo + ResolveConfigMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveConfigMethod "foreach" o = ConfigForeachMethodInfo + ResolveConfigMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveConfigMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveConfigMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveConfigMethod "match" o = ConfigMatchMethodInfo + ResolveConfigMethod "matchForeach" o = ConfigMatchForeachMethodInfo + ResolveConfigMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveConfigMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveConfigMethod "openLevel" o = ConfigOpenLevelMethodInfo + ResolveConfigMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveConfigMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveConfigMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveConfigMethod "snapshot" o = ConfigSnapshotMethodInfo + ResolveConfigMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveConfigMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveConfigMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveConfigMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveConfigMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveConfigMethod "getBool" o = ConfigGetBoolMethodInfo + ResolveConfigMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveConfigMethod "getEntry" o = ConfigGetEntryMethodInfo + ResolveConfigMethod "getInt32" o = ConfigGetInt32MethodInfo + ResolveConfigMethod "getInt64" o = ConfigGetInt64MethodInfo + ResolveConfigMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveConfigMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveConfigMethod "getString" o = ConfigGetStringMethodInfo + ResolveConfigMethod "setBool" o = ConfigSetBoolMethodInfo + ResolveConfigMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveConfigMethod "setInt32" o = ConfigSetInt32MethodInfo + ResolveConfigMethod "setInt64" o = ConfigSetInt64MethodInfo + ResolveConfigMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveConfigMethod "setString" o = ConfigSetStringMethodInfo + ResolveConfigMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveConfigMethod t Config, O.MethodInfo info Config p) => OL.IsLabel t (Config -> 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 Config +type instance O.AttributeList Config = ConfigAttributeList +type ConfigAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Config = ConfigSignalList +type ConfigSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Config::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Config"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_new" ggit_config_new :: + IO (Ptr Config) + +{- | +Create a new config. See also @/ggit_config_get_default()/@ to get +a 'GI.Ggit.Objects.Config.Config' representing the global, XDG and system configuration files. +To get a 'GI.Ggit.Objects.Config.Config' for a repository use @/ggit_repository_get_config/@ +instead. +-} +configNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Config + {- ^ __Returns:__ a 'GI.Ggit.Objects.Config.Config'. -} +configNew = liftIO $ do + result <- ggit_config_new + checkUnexpectedReturnNULL "configNew" result + result' <- (wrapObject Config) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Config::new_default +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Config"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_new_default" ggit_config_new_default :: + Ptr (Ptr GError) -> -- error + IO (Ptr Config) + +{- | +Get the global, XDG and system configuration files merged into one +'GI.Ggit.Objects.Config.Config' with their appropriate priority levels. If an error occured +trying to load the various configuration files, this function will return +'Nothing' and /@error@/ will be set accordingly. +-} +configNewDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + m Config + {- ^ __Returns:__ A 'GI.Ggit.Objects.Config.Config' /(Can throw 'Data.GI.Base.GError.GError')/ -} +configNewDefault = liftIO $ do + onException (do + result <- propagateGError $ ggit_config_new_default + checkUnexpectedReturnNULL "configNewDefault" result + result' <- (newObject Config) result + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Config::new_from_file +-- method type : Constructor +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file to load.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Config"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_new_from_file" ggit_config_new_from_file :: + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Config) + +{- | +Create a new config from a single on disk file. This is a convenience +API and is exactly the same as creating an empty 'GI.Ggit.Objects.Config.Config' using +@/ggit_config_new/@ and adding the file with @/ggit_config_add_file/@. The +level will be set to @/GGIT_CONFIG_LEVEL_LOCAL/@. If the config could not be +loaded this function returns 'Nothing' and /@error@/ will be set accordingly. +-} +configNewFromFile :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@file@/: the file to load. -} + -> m Config + {- ^ __Returns:__ a 'GI.Ggit.Objects.Config.Config'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +configNewFromFile file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + onException (do + result <- propagateGError $ ggit_config_new_from_file file' + checkUnexpectedReturnNULL "configNewFromFile" result + result' <- (wrapObject Config) result + touchManagedPtr file + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Config::add_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface (Name {namespace = "Ggit", name = "ConfigLevel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigLevel.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "force", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if a config file already exists for the given priority level, replace it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_add_file" ggit_config_add_file :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + CInt -> -- level : TInterface (Name {namespace = "Ggit", name = "ConfigLevel"}) + CInt -> -- force : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO () + +{- | +Add an on-disk config file instance to an existing config + +The on-disk file pointed at by /@file@/ will be opened and +parsed; it\'s expected to be a native Git config file following +the default Git config syntax (see man git-config). + +Further queries on this config object will access each +of the config file instances in order (instances with +a higher priority level will be accessed first). +-} +configAddFile :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a, Gio.File.IsFile b) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> b + {- ^ /@file@/: a 'GI.Gio.Interfaces.File.File'. -} + -> Ggit.Enums.ConfigLevel + {- ^ /@level@/: a 'GI.Ggit.Enums.ConfigLevel'. -} + -> Bool + {- ^ /@force@/: if a config file already exists for the given priority level, replace it. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configAddFile config file level force = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + file' <- unsafeManagedPtrCastPtr file + let level' = (fromIntegral . fromEnum) level + let force' = (fromIntegral . fromEnum) force + onException (do + propagateGError $ ggit_config_add_file config' file' level' force' + touchManagedPtr config + touchManagedPtr file + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data ConfigAddFileMethodInfo +instance (signature ~ (b -> Ggit.Enums.ConfigLevel -> Bool -> m ()), MonadIO m, IsConfig a, Gio.File.IsFile b) => O.MethodInfo ConfigAddFileMethodInfo a signature where + overloadedMethod _ = configAddFile + +#endif + +-- method Config::delete_entry +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_delete_entry" ggit_config_delete_entry :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Delete a config variable from the config file. +-} +configDeleteEntry :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the configuration value. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configDeleteEntry config name = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + _ <- propagateGError $ ggit_config_delete_entry config' name' + touchManagedPtr config + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigDeleteEntryMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigDeleteEntryMethodInfo a signature where + overloadedMethod _ = configDeleteEntry + +#endif + +-- method Config::foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "ConfigCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the user data for @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_foreach" ggit_config_foreach :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + FunPtr Ggit.Callbacks.C_ConfigCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "ConfigCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Call /@callback@/ for each configuration value. +-} +configForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> Ggit.Callbacks.ConfigCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.ConfigCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configForeach config callback = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + callback' <- Ggit.Callbacks.mk_ConfigCallback (Ggit.Callbacks.wrap_ConfigCallback Nothing (Ggit.Callbacks.drop_closures_ConfigCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_config_foreach config' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr config + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data ConfigForeachMethodInfo +instance (signature ~ (Ggit.Callbacks.ConfigCallback -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigForeachMethodInfo a signature where + overloadedMethod _ = configForeach + +#endif + +-- method Config::get_bool +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_get_bool" ggit_config_get_bool :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Get a boolean configuration value. +-} +configGetBool :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configGetBool config name = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + _ <- propagateGError $ ggit_config_get_bool config' name' + touchManagedPtr config + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigGetBoolMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigGetBoolMethodInfo a signature where + overloadedMethod _ = configGetBool + +#endif + +-- method Config::get_entry +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the configuration name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "ConfigEntry"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_get_entry" ggit_config_get_entry :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.ConfigEntry.ConfigEntry) + +{- | +Get 'GI.Ggit.Structs.ConfigEntry.ConfigEntry' of a config variable. +-} +configGetEntry :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the configuration name. -} + -> m Ggit.ConfigEntry.ConfigEntry + {- ^ __Returns:__ the entry of /@name@/, or 'Nothing' if such a value + does not exist. /(Can throw 'Data.GI.Base.GError.GError')/ -} +configGetEntry config name = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + result <- propagateGError $ ggit_config_get_entry config' name' + checkUnexpectedReturnNULL "configGetEntry" result + result' <- (wrapBoxed Ggit.ConfigEntry.ConfigEntry) result + touchManagedPtr config + freeMem name' + return result' + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigGetEntryMethodInfo +instance (signature ~ (T.Text -> m Ggit.ConfigEntry.ConfigEntry), MonadIO m, IsConfig a) => O.MethodInfo ConfigGetEntryMethodInfo a signature where + overloadedMethod _ = configGetEntry + +#endif + +-- method Config::get_int32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt32) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_get_int32" ggit_config_get_int32 :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO Int32 + +{- | +Get a int32 configuration value. +-} +configGetInt32 :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> m Int32 + {- ^ __Returns:__ the value. /(Can throw 'Data.GI.Base.GError.GError')/ -} +configGetInt32 config name = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + result <- propagateGError $ ggit_config_get_int32 config' name' + touchManagedPtr config + freeMem name' + return result + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigGetInt32MethodInfo +instance (signature ~ (T.Text -> m Int32), MonadIO m, IsConfig a) => O.MethodInfo ConfigGetInt32MethodInfo a signature where + overloadedMethod _ = configGetInt32 + +#endif + +-- method Config::get_int64 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt64) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_get_int64" ggit_config_get_int64 :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO Int64 + +{- | +Get a int64 configuration value. +-} +configGetInt64 :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> m Int64 + {- ^ __Returns:__ the value. /(Can throw 'Data.GI.Base.GError.GError')/ -} +configGetInt64 config name = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + result <- propagateGError $ ggit_config_get_int64 config' name' + touchManagedPtr config + freeMem name' + return result + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigGetInt64MethodInfo +instance (signature ~ (T.Text -> m Int64), MonadIO m, IsConfig a) => O.MethodInfo ConfigGetInt64MethodInfo a signature where + overloadedMethod _ = configGetInt64 + +#endif + +-- method Config::get_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_get_string" ggit_config_get_string :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CString + +{- | +Get the configuration value of /@name@/ as string. +-} +configGetString :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the string value of /@name@/, or 'Nothing' if such a value + does not exist /(Can throw 'Data.GI.Base.GError.GError')/ -} +configGetString config name = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + result <- propagateGError $ ggit_config_get_string config' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr config + freeMem name' + return maybeResult + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigGetStringMethodInfo +instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsConfig a) => O.MethodInfo ConfigGetStringMethodInfo a signature where + overloadedMethod _ = configGetString + +#endif + +-- method Config::match +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "regex", argType = TInterface (Name {namespace = "GLib", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GRegex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_info", argType = TInterface (Name {namespace = "GLib", name = "MatchInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMatchInfo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_match" ggit_config_match :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + Ptr GLib.Regex.Regex -> -- regex : TInterface (Name {namespace = "GLib", name = "Regex"}) + Ptr (Ptr GLib.MatchInfo.MatchInfo) -> -- match_info : TInterface (Name {namespace = "GLib", name = "MatchInfo"}) + Ptr (Ptr GError) -> -- error + IO CString + +{- | +Matches a configuration against a regular expression. /@matchInfo@/ will +contain the match information if the return value is not 'Nothing', otherwise +/@error@/ will be set. +-} +configMatch :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> GLib.Regex.Regex + {- ^ /@regex@/: a 'GI.GLib.Structs.Regex.Regex'. -} + -> m ((Maybe T.Text, GLib.MatchInfo.MatchInfo)) + {- ^ __Returns:__ the value of that matched configuration /(Can throw 'Data.GI.Base.GError.GError')/ -} +configMatch config regex = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + regex' <- unsafeManagedPtrGetPtr regex + matchInfo <- allocMem :: IO (Ptr (Ptr GLib.MatchInfo.MatchInfo)) + onException (do + result <- propagateGError $ ggit_config_match config' regex' matchInfo + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + matchInfo' <- peek matchInfo + matchInfo'' <- (wrapBoxed GLib.MatchInfo.MatchInfo) matchInfo' + touchManagedPtr config + touchManagedPtr regex + freeMem matchInfo + return (maybeResult, matchInfo'') + ) (do + freeMem matchInfo + ) + +#if ENABLE_OVERLOADING +data ConfigMatchMethodInfo +instance (signature ~ (GLib.Regex.Regex -> m ((Maybe T.Text, GLib.MatchInfo.MatchInfo))), MonadIO m, IsConfig a) => O.MethodInfo ConfigMatchMethodInfo a signature where + overloadedMethod _ = configMatch + +#endif + +-- method Config::match_foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "regex", argType = TInterface (Name {namespace = "GLib", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GRegex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "ConfigMatchCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigMatchCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the user data for @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_match_foreach" ggit_config_match_foreach :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + Ptr GLib.Regex.Regex -> -- regex : TInterface (Name {namespace = "GLib", name = "Regex"}) + FunPtr Ggit.Callbacks.C_ConfigMatchCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "ConfigMatchCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Call /@callback@/ for all configurations matching /@regex@/. +-} +configMatchForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> GLib.Regex.Regex + {- ^ /@regex@/: a 'GI.GLib.Structs.Regex.Regex'. -} + -> Ggit.Callbacks.ConfigMatchCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.ConfigMatchCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configMatchForeach config regex callback = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + regex' <- unsafeManagedPtrGetPtr regex + callback' <- Ggit.Callbacks.mk_ConfigMatchCallback (Ggit.Callbacks.wrap_ConfigMatchCallback Nothing (Ggit.Callbacks.drop_closures_ConfigMatchCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_config_match_foreach config' regex' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr config + touchManagedPtr regex + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data ConfigMatchForeachMethodInfo +instance (signature ~ (GLib.Regex.Regex -> Ggit.Callbacks.ConfigMatchCallback -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigMatchForeachMethodInfo a signature where + overloadedMethod _ = configMatchForeach + +#endif + +-- method Config::open_level +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface (Name {namespace = "Ggit", name = "ConfigLevel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the level to open.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Config"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_open_level" ggit_config_open_level :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CInt -> -- level : TInterface (Name {namespace = "Ggit", name = "ConfigLevel"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Config) + +{- | +Open a specific level config derived from a multi-level one. +-} +configOpenLevel :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> Ggit.Enums.ConfigLevel + {- ^ /@level@/: the level to open. -} + -> m Config + {- ^ __Returns:__ the configuration at /@level@/, or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +configOpenLevel config level = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + let level' = (fromIntegral . fromEnum) level + onException (do + result <- propagateGError $ ggit_config_open_level config' level' + checkUnexpectedReturnNULL "configOpenLevel" result + result' <- (wrapObject Config) result + touchManagedPtr config + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data ConfigOpenLevelMethodInfo +instance (signature ~ (Ggit.Enums.ConfigLevel -> m Config), MonadIO m, IsConfig a) => O.MethodInfo ConfigOpenLevelMethodInfo a signature where + overloadedMethod _ = configOpenLevel + +#endif + +-- method Config::set_bool +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_set_bool" ggit_config_set_bool :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + CInt -> -- value : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Set a boolean value. +-} +configSetBool :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> Bool + {- ^ /@value@/: the new value. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configSetBool config name value = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + let value' = (fromIntegral . fromEnum) value + onException (do + _ <- propagateGError $ ggit_config_set_bool config' name' value' + touchManagedPtr config + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigSetBoolMethodInfo +instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigSetBoolMethodInfo a signature where + overloadedMethod _ = configSetBool + +#endif + +-- method Config::set_int32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_set_int32" ggit_config_set_int32 :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Int32 -> -- value : TBasicType TInt32 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Set a int32 value. +-} +configSetInt32 :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> Int32 + {- ^ /@value@/: the new value. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configSetInt32 config name value = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + _ <- propagateGError $ ggit_config_set_int32 config' name' value + touchManagedPtr config + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigSetInt32MethodInfo +instance (signature ~ (T.Text -> Int32 -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigSetInt32MethodInfo a signature where + overloadedMethod _ = configSetInt32 + +#endif + +-- method Config::set_int64 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_set_int64" ggit_config_set_int64 :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + Int64 -> -- value : TBasicType TInt64 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Set a int64 value. +-} +configSetInt64 :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> Int64 + {- ^ /@value@/: the new value. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configSetInt64 config name value = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + onException (do + _ <- propagateGError $ ggit_config_set_int64 config' name' value + touchManagedPtr config + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data ConfigSetInt64MethodInfo +instance (signature ~ (T.Text -> Int64 -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigSetInt64MethodInfo a signature where + overloadedMethod _ = configSetInt64 + +#endif + +-- method Config::set_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the configuration value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_set_string" ggit_config_set_string :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- value : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Set a new string value of a configuration. +-} +configSetString :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> T.Text + {- ^ /@name@/: the name of the configuration value. -} + -> T.Text + {- ^ /@value@/: the new value. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +configSetString config name value = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + name' <- textToCString name + value' <- textToCString value + onException (do + _ <- propagateGError $ ggit_config_set_string config' name' value' + touchManagedPtr config + freeMem name' + freeMem value' + return () + ) (do + freeMem name' + freeMem value' + ) + +#if ENABLE_OVERLOADING +data ConfigSetStringMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsConfig a) => O.MethodInfo ConfigSetStringMethodInfo a signature where + overloadedMethod _ = configSetString + +#endif + +-- method Config::snapshot +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Ggit", name = "Config"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfig.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Config"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_config_snapshot" ggit_config_snapshot :: + Ptr Config -> -- config : TInterface (Name {namespace = "Ggit", name = "Config"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Config) + +{- | +Create a snapshot of the current state of the configuration, +which allows you to look into a consistent view of the configuration +for looking up complex values (e.g. a remote, submodule). +-} +configSnapshot :: + (B.CallStack.HasCallStack, MonadIO m, IsConfig a) => + a + {- ^ /@config@/: a 'GI.Ggit.Objects.Config.Config'. -} + -> m Config + {- ^ __Returns:__ a new 'GI.Ggit.Objects.Config.Config', or 'Nothing' if an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -} +configSnapshot config = liftIO $ do + config' <- unsafeManagedPtrCastPtr config + onException (do + result <- propagateGError $ ggit_config_snapshot config' + checkUnexpectedReturnNULL "configSnapshot" result + result' <- (wrapObject Config) result + touchManagedPtr config + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data ConfigSnapshotMethodInfo +instance (signature ~ (m Config), MonadIO m, IsConfig a) => O.MethodInfo ConfigSnapshotMethodInfo a signature where + overloadedMethod _ = configSnapshot + +#endif + +-- method Config::find_global +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_find_global" ggit_config_find_global :: + IO (Ptr Gio.File.File) + +{- | +Find the file representing the users global git configuration. This file +is usually located at $HOME\/.gitconfig. This function will try to guess +the full path to that file, if the file exists. The returned file may then +be used with @/ggit_config_new_from_file/@ or @/ggit_config_add_file/@. This +function returns 'Nothing' if the global config could not be found. +-} +configFindGlobal :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gio.File.File + {- ^ __Returns:__ a 'GI.Gio.Interfaces.File.File' or 'Nothing' if the global config could not be found. -} +configFindGlobal = liftIO $ do + result <- ggit_config_find_global + checkUnexpectedReturnNULL "configFindGlobal" result + result' <- (wrapObject Gio.File.File) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Config::find_system +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_find_system" ggit_config_find_system :: + IO (Ptr Gio.File.File) + +{- | +Find the file representing the systems global git configuration. This file +is usually located at \/etc\/gitconfig on UNIX type systems or +@/PROGRAMFILES/@%\\Git\\etc\\gitconfig on windows. This function will try to guess +the full path to that file, if the file exists. The returned file may then +be used with @/ggit_config_new_from_file/@ or @/ggit_config_add_file/@. This +function returns 'Nothing' if the system config could not be found. +-} +configFindSystem :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gio.File.File + {- ^ __Returns:__ a 'GI.Gio.Interfaces.File.File' or 'Nothing' if the system config could not + be found. -} +configFindSystem = liftIO $ do + result <- ggit_config_find_system + checkUnexpectedReturnNULL "configFindSystem" result + result' <- (wrapObject Gio.File.File) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/Ggit/Objects/Config.hs-boot b/GI/Ggit/Objects/Config.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Config.hs-boot @@ -0,0 +1,77 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Config 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 + +newtype Config = Config (ManagedPtr Config) +instance GObject Config where +class (GObject o, O.IsDescendantOf Config o) => IsConfig o +instance (GObject o, O.IsDescendantOf Config o) => IsConfig o +instance O.HasParentTypes Config +#if ENABLE_OVERLOADING +data ConfigAddFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigDeleteEntryMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigGetBoolMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigGetEntryMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigGetInt32MethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigGetInt64MethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigGetStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigMatchMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigMatchForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigOpenLevelMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigSetBoolMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigSetInt32MethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigSetInt64MethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigSetStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigSnapshotMethodInfo +#endif diff --git a/GI/Ggit/Objects/Cred.hs b/GI/Ggit/Objects/Cred.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Cred.hs @@ -0,0 +1,123 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git credential. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Cred + ( + +-- * Exported types + Cred(..) , + IsCred , + toCred , + noCred , + + + ) 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.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase + +-- | Memory-managed wrapper type. +newtype Cred = Cred (ManagedPtr Cred) +foreign import ccall "ggit_cred_get_type" + c_ggit_cred_get_type :: IO GType + +instance GObject Cred where + gobjectType = c_ggit_cred_get_type + + +-- | Type class for types which can be safely cast to `Cred`, for instance with `toCred`. +class (GObject o, O.IsDescendantOf Cred o) => IsCred o +instance (GObject o, O.IsDescendantOf Cred o) => IsCred o + +instance O.HasParentTypes Cred +type instance O.ParentTypes Cred = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Cred`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCred :: (MonadIO m, IsCred o) => o -> m Cred +toCred = liftIO . unsafeCastTo Cred + +-- | A convenience alias for `Nothing` :: `Maybe` `Cred`. +noCred :: Maybe Cred +noCred = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCredMethod (t :: Symbol) (o :: *) :: * where + ResolveCredMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCredMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCredMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCredMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCredMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCredMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCredMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCredMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCredMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCredMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCredMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCredMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCredMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCredMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCredMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCredMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCredMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCredMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCredMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCredMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCredMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCredMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCredMethod t Cred, O.MethodInfo info Cred p) => OL.IsLabel t (Cred -> 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 Cred +type instance O.AttributeList Cred = CredAttributeList +type CredAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Cred = CredSignalList +type CredSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/Ggit/Objects/Cred.hs-boot b/GI/Ggit/Objects/Cred.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Cred.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Cred 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 + +newtype Cred = Cred (ManagedPtr Cred) +instance GObject Cred where +class (GObject o, O.IsDescendantOf Cred o) => IsCred o +instance (GObject o, O.IsDescendantOf Cred o) => IsCred o +instance O.HasParentTypes Cred diff --git a/GI/Ggit/Objects/CredPlaintext.hs b/GI/Ggit/Objects/CredPlaintext.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CredPlaintext.hs @@ -0,0 +1,370 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a plain text credential. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.CredPlaintext + ( + +-- * Exported types + CredPlaintext(..) , + IsCredPlaintext , + toCredPlaintext , + noCredPlaintext , + + + -- * Methods +-- ** getPassword #method:getPassword# + +#if ENABLE_OVERLOADING + CredPlaintextGetPasswordMethodInfo , +#endif + credPlaintextGetPassword , + + +-- ** getUsername #method:getUsername# + +#if ENABLE_OVERLOADING + CredPlaintextGetUsernameMethodInfo , +#endif + credPlaintextGetUsername , + + +-- ** new #method:new# + + credPlaintextNew , + + + + + -- * Properties +-- ** password #attr:password# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CredPlaintextPasswordPropertyInfo , +#endif + constructCredPlaintextPassword , +#if ENABLE_OVERLOADING + credPlaintextPassword , +#endif + getCredPlaintextPassword , + + +-- ** username #attr:username# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CredPlaintextUsernamePropertyInfo , +#endif + constructCredPlaintextUsername , +#if ENABLE_OVERLOADING + credPlaintextUsername , +#endif + getCredPlaintextUsername , + + + + + ) 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.Objects.Cred as Ggit.Cred +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import qualified GI.Gio.Interfaces.Initable as Gio.Initable + +-- | Memory-managed wrapper type. +newtype CredPlaintext = CredPlaintext (ManagedPtr CredPlaintext) +foreign import ccall "ggit_cred_plaintext_get_type" + c_ggit_cred_plaintext_get_type :: IO GType + +instance GObject CredPlaintext where + gobjectType = c_ggit_cred_plaintext_get_type + + +-- | Type class for types which can be safely cast to `CredPlaintext`, for instance with `toCredPlaintext`. +class (GObject o, O.IsDescendantOf CredPlaintext o) => IsCredPlaintext o +instance (GObject o, O.IsDescendantOf CredPlaintext o) => IsCredPlaintext o + +instance O.HasParentTypes CredPlaintext +type instance O.ParentTypes CredPlaintext = '[Ggit.Cred.Cred, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `CredPlaintext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCredPlaintext :: (MonadIO m, IsCredPlaintext o) => o -> m CredPlaintext +toCredPlaintext = liftIO . unsafeCastTo CredPlaintext + +-- | A convenience alias for `Nothing` :: `Maybe` `CredPlaintext`. +noCredPlaintext :: Maybe CredPlaintext +noCredPlaintext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCredPlaintextMethod (t :: Symbol) (o :: *) :: * where + ResolveCredPlaintextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCredPlaintextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCredPlaintextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCredPlaintextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCredPlaintextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCredPlaintextMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveCredPlaintextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCredPlaintextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCredPlaintextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCredPlaintextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCredPlaintextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCredPlaintextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCredPlaintextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCredPlaintextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCredPlaintextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCredPlaintextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCredPlaintextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCredPlaintextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCredPlaintextMethod "getPassword" o = CredPlaintextGetPasswordMethodInfo + ResolveCredPlaintextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCredPlaintextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCredPlaintextMethod "getUsername" o = CredPlaintextGetUsernameMethodInfo + ResolveCredPlaintextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCredPlaintextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCredPlaintextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCredPlaintextMethod t CredPlaintext, O.MethodInfo info CredPlaintext p) => OL.IsLabel t (CredPlaintext -> 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 + +-- VVV Prop "password" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@password@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' credPlaintext #password +@ +-} +getCredPlaintextPassword :: (MonadIO m, IsCredPlaintext o) => o -> m T.Text +getCredPlaintextPassword obj = liftIO $ checkUnexpectedNothing "getCredPlaintextPassword" $ B.Properties.getObjectPropertyString obj "password" + +{- | +Construct a `GValueConstruct` with valid value for the “@password@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCredPlaintextPassword :: (IsCredPlaintext o) => T.Text -> IO (GValueConstruct o) +constructCredPlaintextPassword val = B.Properties.constructObjectPropertyString "password" (Just val) + +#if ENABLE_OVERLOADING +data CredPlaintextPasswordPropertyInfo +instance AttrInfo CredPlaintextPasswordPropertyInfo where + type AttrAllowedOps CredPlaintextPasswordPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CredPlaintextPasswordPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CredPlaintextPasswordPropertyInfo = IsCredPlaintext + type AttrGetType CredPlaintextPasswordPropertyInfo = T.Text + type AttrLabel CredPlaintextPasswordPropertyInfo = "password" + type AttrOrigin CredPlaintextPasswordPropertyInfo = CredPlaintext + attrGet _ = getCredPlaintextPassword + attrSet _ = undefined + attrConstruct _ = constructCredPlaintextPassword + attrClear _ = undefined +#endif + +-- VVV Prop "username" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@username@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' credPlaintext #username +@ +-} +getCredPlaintextUsername :: (MonadIO m, IsCredPlaintext o) => o -> m T.Text +getCredPlaintextUsername obj = liftIO $ checkUnexpectedNothing "getCredPlaintextUsername" $ B.Properties.getObjectPropertyString obj "username" + +{- | +Construct a `GValueConstruct` with valid value for the “@username@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCredPlaintextUsername :: (IsCredPlaintext o) => T.Text -> IO (GValueConstruct o) +constructCredPlaintextUsername val = B.Properties.constructObjectPropertyString "username" (Just val) + +#if ENABLE_OVERLOADING +data CredPlaintextUsernamePropertyInfo +instance AttrInfo CredPlaintextUsernamePropertyInfo where + type AttrAllowedOps CredPlaintextUsernamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CredPlaintextUsernamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CredPlaintextUsernamePropertyInfo = IsCredPlaintext + type AttrGetType CredPlaintextUsernamePropertyInfo = T.Text + type AttrLabel CredPlaintextUsernamePropertyInfo = "username" + type AttrOrigin CredPlaintextUsernamePropertyInfo = CredPlaintext + attrGet _ = getCredPlaintextUsername + attrSet _ = undefined + attrConstruct _ = constructCredPlaintextUsername + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CredPlaintext +type instance O.AttributeList CredPlaintext = CredPlaintextAttributeList +type CredPlaintextAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo), '("password", CredPlaintextPasswordPropertyInfo), '("username", CredPlaintextUsernamePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +credPlaintextPassword :: AttrLabelProxy "password" +credPlaintextPassword = AttrLabelProxy + +credPlaintextUsername :: AttrLabelProxy "username" +credPlaintextUsername = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CredPlaintext = CredPlaintextSignalList +type CredPlaintextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CredPlaintext::new +-- method type : Constructor +-- Args : [Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CredPlaintext"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_cred_plaintext_new" ggit_cred_plaintext_new :: + CString -> -- username : TBasicType TUTF8 + CString -> -- password : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr CredPlaintext) + +{- | +/No description available in the introspection data./ +-} +credPlaintextNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> T.Text + -> m CredPlaintext + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +credPlaintextNew username password = liftIO $ do + username' <- textToCString username + password' <- textToCString password + onException (do + result <- propagateGError $ ggit_cred_plaintext_new username' password' + checkUnexpectedReturnNULL "credPlaintextNew" result + result' <- (wrapObject CredPlaintext) result + freeMem username' + freeMem password' + return result' + ) (do + freeMem username' + freeMem password' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method CredPlaintext::get_password +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cred", argType = TInterface (Name {namespace = "Ggit", name = "CredPlaintext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_plaintext_get_password" ggit_cred_plaintext_get_password :: + Ptr CredPlaintext -> -- cred : TInterface (Name {namespace = "Ggit", name = "CredPlaintext"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +credPlaintextGetPassword :: + (B.CallStack.HasCallStack, MonadIO m, IsCredPlaintext a) => + a + -> m T.Text +credPlaintextGetPassword cred = liftIO $ do + cred' <- unsafeManagedPtrCastPtr cred + result <- ggit_cred_plaintext_get_password cred' + checkUnexpectedReturnNULL "credPlaintextGetPassword" result + result' <- cstringToText result + touchManagedPtr cred + return result' + +#if ENABLE_OVERLOADING +data CredPlaintextGetPasswordMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCredPlaintext a) => O.MethodInfo CredPlaintextGetPasswordMethodInfo a signature where + overloadedMethod _ = credPlaintextGetPassword + +#endif + +-- method CredPlaintext::get_username +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cred", argType = TInterface (Name {namespace = "Ggit", name = "CredPlaintext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_plaintext_get_username" ggit_cred_plaintext_get_username :: + Ptr CredPlaintext -> -- cred : TInterface (Name {namespace = "Ggit", name = "CredPlaintext"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +credPlaintextGetUsername :: + (B.CallStack.HasCallStack, MonadIO m, IsCredPlaintext a) => + a + -> m T.Text +credPlaintextGetUsername cred = liftIO $ do + cred' <- unsafeManagedPtrCastPtr cred + result <- ggit_cred_plaintext_get_username cred' + checkUnexpectedReturnNULL "credPlaintextGetUsername" result + result' <- cstringToText result + touchManagedPtr cred + return result' + +#if ENABLE_OVERLOADING +data CredPlaintextGetUsernameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCredPlaintext a) => O.MethodInfo CredPlaintextGetUsernameMethodInfo a signature where + overloadedMethod _ = credPlaintextGetUsername + +#endif + + diff --git a/GI/Ggit/Objects/CredPlaintext.hs-boot b/GI/Ggit/Objects/CredPlaintext.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CredPlaintext.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.CredPlaintext 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 + +newtype CredPlaintext = CredPlaintext (ManagedPtr CredPlaintext) +instance GObject CredPlaintext where +class (GObject o, O.IsDescendantOf CredPlaintext o) => IsCredPlaintext o +instance (GObject o, O.IsDescendantOf CredPlaintext o) => IsCredPlaintext o +instance O.HasParentTypes CredPlaintext +#if ENABLE_OVERLOADING +data CredPlaintextPasswordPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CredPlaintextUsernamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CredPlaintextGetPasswordMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredPlaintextGetUsernameMethodInfo +#endif diff --git a/GI/Ggit/Objects/CredSshInteractive.hs b/GI/Ggit/Objects/CredSshInteractive.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CredSshInteractive.hs @@ -0,0 +1,269 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a ssh interactive credential. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.CredSshInteractive + ( + +-- * Exported types + CredSshInteractive(..) , + IsCredSshInteractive , + toCredSshInteractive , + noCredSshInteractive , + + + -- * Methods +-- ** getUsername #method:getUsername# + +#if ENABLE_OVERLOADING + CredSshInteractiveGetUsernameMethodInfo , +#endif + credSshInteractiveGetUsername , + + +-- ** new #method:new# + + credSshInteractiveNew , + + + + + -- * Properties +-- ** username #attr:username# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CredSshInteractiveUsernamePropertyInfo , +#endif + constructCredSshInteractiveUsername , +#if ENABLE_OVERLOADING + credSshInteractiveUsername , +#endif + getCredSshInteractiveUsername , + + + + + ) 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.Objects.Cred as Ggit.Cred +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import qualified GI.Gio.Interfaces.Initable as Gio.Initable + +-- | Memory-managed wrapper type. +newtype CredSshInteractive = CredSshInteractive (ManagedPtr CredSshInteractive) +foreign import ccall "ggit_cred_ssh_interactive_get_type" + c_ggit_cred_ssh_interactive_get_type :: IO GType + +instance GObject CredSshInteractive where + gobjectType = c_ggit_cred_ssh_interactive_get_type + + +-- | Type class for types which can be safely cast to `CredSshInteractive`, for instance with `toCredSshInteractive`. +class (GObject o, O.IsDescendantOf CredSshInteractive o) => IsCredSshInteractive o +instance (GObject o, O.IsDescendantOf CredSshInteractive o) => IsCredSshInteractive o + +instance O.HasParentTypes CredSshInteractive +type instance O.ParentTypes CredSshInteractive = '[Ggit.Cred.Cred, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `CredSshInteractive`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCredSshInteractive :: (MonadIO m, IsCredSshInteractive o) => o -> m CredSshInteractive +toCredSshInteractive = liftIO . unsafeCastTo CredSshInteractive + +-- | A convenience alias for `Nothing` :: `Maybe` `CredSshInteractive`. +noCredSshInteractive :: Maybe CredSshInteractive +noCredSshInteractive = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCredSshInteractiveMethod (t :: Symbol) (o :: *) :: * where + ResolveCredSshInteractiveMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCredSshInteractiveMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCredSshInteractiveMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCredSshInteractiveMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCredSshInteractiveMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCredSshInteractiveMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveCredSshInteractiveMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCredSshInteractiveMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCredSshInteractiveMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCredSshInteractiveMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCredSshInteractiveMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCredSshInteractiveMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCredSshInteractiveMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCredSshInteractiveMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCredSshInteractiveMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCredSshInteractiveMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCredSshInteractiveMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCredSshInteractiveMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCredSshInteractiveMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCredSshInteractiveMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCredSshInteractiveMethod "getUsername" o = CredSshInteractiveGetUsernameMethodInfo + ResolveCredSshInteractiveMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCredSshInteractiveMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCredSshInteractiveMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCredSshInteractiveMethod t CredSshInteractive, O.MethodInfo info CredSshInteractive p) => OL.IsLabel t (CredSshInteractive -> 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 + +-- VVV Prop "username" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@username@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' credSshInteractive #username +@ +-} +getCredSshInteractiveUsername :: (MonadIO m, IsCredSshInteractive o) => o -> m T.Text +getCredSshInteractiveUsername obj = liftIO $ checkUnexpectedNothing "getCredSshInteractiveUsername" $ B.Properties.getObjectPropertyString obj "username" + +{- | +Construct a `GValueConstruct` with valid value for the “@username@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCredSshInteractiveUsername :: (IsCredSshInteractive o) => T.Text -> IO (GValueConstruct o) +constructCredSshInteractiveUsername val = B.Properties.constructObjectPropertyString "username" (Just val) + +#if ENABLE_OVERLOADING +data CredSshInteractiveUsernamePropertyInfo +instance AttrInfo CredSshInteractiveUsernamePropertyInfo where + type AttrAllowedOps CredSshInteractiveUsernamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CredSshInteractiveUsernamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CredSshInteractiveUsernamePropertyInfo = IsCredSshInteractive + type AttrGetType CredSshInteractiveUsernamePropertyInfo = T.Text + type AttrLabel CredSshInteractiveUsernamePropertyInfo = "username" + type AttrOrigin CredSshInteractiveUsernamePropertyInfo = CredSshInteractive + attrGet _ = getCredSshInteractiveUsername + attrSet _ = undefined + attrConstruct _ = constructCredSshInteractiveUsername + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CredSshInteractive +type instance O.AttributeList CredSshInteractive = CredSshInteractiveAttributeList +type CredSshInteractiveAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo), '("username", CredSshInteractiveUsernamePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +credSshInteractiveUsername :: AttrLabelProxy "username" +credSshInteractiveUsername = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CredSshInteractive = CredSshInteractiveSignalList +type CredSshInteractiveSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CredSshInteractive::new +-- method type : Constructor +-- Args : [Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CredSshInteractive"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_new" ggit_cred_ssh_interactive_new :: + CString -> -- username : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr CredSshInteractive) + +{- | +/No description available in the introspection data./ +-} +credSshInteractiveNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> m CredSshInteractive + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +credSshInteractiveNew username = liftIO $ do + username' <- textToCString username + onException (do + result <- propagateGError $ ggit_cred_ssh_interactive_new username' + checkUnexpectedReturnNULL "credSshInteractiveNew" result + result' <- (wrapObject CredSshInteractive) result + freeMem username' + return result' + ) (do + freeMem username' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method CredSshInteractive::get_username +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cred", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractive"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_get_username" ggit_cred_ssh_interactive_get_username :: + Ptr CredSshInteractive -> -- cred : TInterface (Name {namespace = "Ggit", name = "CredSshInteractive"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +credSshInteractiveGetUsername :: + (B.CallStack.HasCallStack, MonadIO m, IsCredSshInteractive a) => + a + -> m T.Text +credSshInteractiveGetUsername cred = liftIO $ do + cred' <- unsafeManagedPtrCastPtr cred + result <- ggit_cred_ssh_interactive_get_username cred' + checkUnexpectedReturnNULL "credSshInteractiveGetUsername" result + result' <- cstringToText result + touchManagedPtr cred + return result' + +#if ENABLE_OVERLOADING +data CredSshInteractiveGetUsernameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCredSshInteractive a) => O.MethodInfo CredSshInteractiveGetUsernameMethodInfo a signature where + overloadedMethod _ = credSshInteractiveGetUsername + +#endif + + diff --git a/GI/Ggit/Objects/CredSshInteractive.hs-boot b/GI/Ggit/Objects/CredSshInteractive.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CredSshInteractive.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.CredSshInteractive 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 + +newtype CredSshInteractive = CredSshInteractive (ManagedPtr CredSshInteractive) +instance GObject CredSshInteractive where +class (GObject o, O.IsDescendantOf CredSshInteractive o) => IsCredSshInteractive o +instance (GObject o, O.IsDescendantOf CredSshInteractive o) => IsCredSshInteractive o +instance O.HasParentTypes CredSshInteractive +#if ENABLE_OVERLOADING +data CredSshInteractiveUsernamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractiveGetUsernameMethodInfo +#endif diff --git a/GI/Ggit/Objects/CredSshKeyFromAgent.hs b/GI/Ggit/Objects/CredSshKeyFromAgent.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CredSshKeyFromAgent.hs @@ -0,0 +1,274 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a ssh key agent credential. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.CredSshKeyFromAgent + ( + +-- * Exported types + CredSshKeyFromAgent(..) , + IsCredSshKeyFromAgent , + toCredSshKeyFromAgent , + noCredSshKeyFromAgent , + + + -- * Methods +-- ** getUsername #method:getUsername# + +#if ENABLE_OVERLOADING + CredSshKeyFromAgentGetUsernameMethodInfo, +#endif + credSshKeyFromAgentGetUsername , + + +-- ** new #method:new# + + credSshKeyFromAgentNew , + + + + + -- * Properties +-- ** username #attr:username# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CredSshKeyFromAgentUsernamePropertyInfo , +#endif + constructCredSshKeyFromAgentUsername , +#if ENABLE_OVERLOADING + credSshKeyFromAgentUsername , +#endif + getCredSshKeyFromAgentUsername , + + + + + ) 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.Objects.Cred as Ggit.Cred +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import qualified GI.Gio.Interfaces.Initable as Gio.Initable + +-- | Memory-managed wrapper type. +newtype CredSshKeyFromAgent = CredSshKeyFromAgent (ManagedPtr CredSshKeyFromAgent) +foreign import ccall "ggit_cred_ssh_key_from_agent_get_type" + c_ggit_cred_ssh_key_from_agent_get_type :: IO GType + +instance GObject CredSshKeyFromAgent where + gobjectType = c_ggit_cred_ssh_key_from_agent_get_type + + +-- | Type class for types which can be safely cast to `CredSshKeyFromAgent`, for instance with `toCredSshKeyFromAgent`. +class (GObject o, O.IsDescendantOf CredSshKeyFromAgent o) => IsCredSshKeyFromAgent o +instance (GObject o, O.IsDescendantOf CredSshKeyFromAgent o) => IsCredSshKeyFromAgent o + +instance O.HasParentTypes CredSshKeyFromAgent +type instance O.ParentTypes CredSshKeyFromAgent = '[Ggit.Cred.Cred, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `CredSshKeyFromAgent`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCredSshKeyFromAgent :: (MonadIO m, IsCredSshKeyFromAgent o) => o -> m CredSshKeyFromAgent +toCredSshKeyFromAgent = liftIO . unsafeCastTo CredSshKeyFromAgent + +-- | A convenience alias for `Nothing` :: `Maybe` `CredSshKeyFromAgent`. +noCredSshKeyFromAgent :: Maybe CredSshKeyFromAgent +noCredSshKeyFromAgent = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCredSshKeyFromAgentMethod (t :: Symbol) (o :: *) :: * where + ResolveCredSshKeyFromAgentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCredSshKeyFromAgentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCredSshKeyFromAgentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCredSshKeyFromAgentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCredSshKeyFromAgentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCredSshKeyFromAgentMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveCredSshKeyFromAgentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCredSshKeyFromAgentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCredSshKeyFromAgentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCredSshKeyFromAgentMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCredSshKeyFromAgentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCredSshKeyFromAgentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCredSshKeyFromAgentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCredSshKeyFromAgentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCredSshKeyFromAgentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCredSshKeyFromAgentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCredSshKeyFromAgentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCredSshKeyFromAgentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCredSshKeyFromAgentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCredSshKeyFromAgentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCredSshKeyFromAgentMethod "getUsername" o = CredSshKeyFromAgentGetUsernameMethodInfo + ResolveCredSshKeyFromAgentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCredSshKeyFromAgentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCredSshKeyFromAgentMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCredSshKeyFromAgentMethod t CredSshKeyFromAgent, O.MethodInfo info CredSshKeyFromAgent p) => OL.IsLabel t (CredSshKeyFromAgent -> 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 + +-- VVV Prop "username" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@username@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' credSshKeyFromAgent #username +@ +-} +getCredSshKeyFromAgentUsername :: (MonadIO m, IsCredSshKeyFromAgent o) => o -> m (Maybe T.Text) +getCredSshKeyFromAgentUsername obj = liftIO $ B.Properties.getObjectPropertyString obj "username" + +{- | +Construct a `GValueConstruct` with valid value for the “@username@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCredSshKeyFromAgentUsername :: (IsCredSshKeyFromAgent o) => T.Text -> IO (GValueConstruct o) +constructCredSshKeyFromAgentUsername val = B.Properties.constructObjectPropertyString "username" (Just val) + +#if ENABLE_OVERLOADING +data CredSshKeyFromAgentUsernamePropertyInfo +instance AttrInfo CredSshKeyFromAgentUsernamePropertyInfo where + type AttrAllowedOps CredSshKeyFromAgentUsernamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CredSshKeyFromAgentUsernamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CredSshKeyFromAgentUsernamePropertyInfo = IsCredSshKeyFromAgent + type AttrGetType CredSshKeyFromAgentUsernamePropertyInfo = (Maybe T.Text) + type AttrLabel CredSshKeyFromAgentUsernamePropertyInfo = "username" + type AttrOrigin CredSshKeyFromAgentUsernamePropertyInfo = CredSshKeyFromAgent + attrGet _ = getCredSshKeyFromAgentUsername + attrSet _ = undefined + attrConstruct _ = constructCredSshKeyFromAgentUsername + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CredSshKeyFromAgent +type instance O.AttributeList CredSshKeyFromAgent = CredSshKeyFromAgentAttributeList +type CredSshKeyFromAgentAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo), '("username", CredSshKeyFromAgentUsernamePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +credSshKeyFromAgentUsername :: AttrLabelProxy "username" +credSshKeyFromAgentUsername = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CredSshKeyFromAgent = CredSshKeyFromAgentSignalList +type CredSshKeyFromAgentSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CredSshKeyFromAgent::new +-- method type : Constructor +-- Args : [Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the username.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CredSshKeyFromAgent"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_key_from_agent_new" ggit_cred_ssh_key_from_agent_new :: + CString -> -- username : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr CredSshKeyFromAgent) + +{- | +Creates a new 'GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent'. +-} +credSshKeyFromAgentNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@username@/: the username. -} + -> m (Maybe CredSshKeyFromAgent) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent' or 'Nothing' if there was an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +credSshKeyFromAgentNew username = liftIO $ do + username' <- textToCString username + onException (do + result <- propagateGError $ ggit_cred_ssh_key_from_agent_new username' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject CredSshKeyFromAgent) result' + return result'' + freeMem username' + return maybeResult + ) (do + freeMem username' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method CredSshKeyFromAgent::get_username +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cred", argType = TInterface (Name {namespace = "Ggit", name = "CredSshKeyFromAgent"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCredSshKeyFromAgent.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_key_from_agent_get_username" ggit_cred_ssh_key_from_agent_get_username :: + Ptr CredSshKeyFromAgent -> -- cred : TInterface (Name {namespace = "Ggit", name = "CredSshKeyFromAgent"}) + IO CString + +{- | +Gets the username for the credential. +-} +credSshKeyFromAgentGetUsername :: + (B.CallStack.HasCallStack, MonadIO m, IsCredSshKeyFromAgent a) => + a + {- ^ /@cred@/: a 'GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the username or 'Nothing'. -} +credSshKeyFromAgentGetUsername cred = liftIO $ do + cred' <- unsafeManagedPtrCastPtr cred + result <- ggit_cred_ssh_key_from_agent_get_username cred' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr cred + return maybeResult + +#if ENABLE_OVERLOADING +data CredSshKeyFromAgentGetUsernameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCredSshKeyFromAgent a) => O.MethodInfo CredSshKeyFromAgentGetUsernameMethodInfo a signature where + overloadedMethod _ = credSshKeyFromAgentGetUsername + +#endif + + diff --git a/GI/Ggit/Objects/CredSshKeyFromAgent.hs-boot b/GI/Ggit/Objects/CredSshKeyFromAgent.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/CredSshKeyFromAgent.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.CredSshKeyFromAgent 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 + +newtype CredSshKeyFromAgent = CredSshKeyFromAgent (ManagedPtr CredSshKeyFromAgent) +instance GObject CredSshKeyFromAgent where +class (GObject o, O.IsDescendantOf CredSshKeyFromAgent o) => IsCredSshKeyFromAgent o +instance (GObject o, O.IsDescendantOf CredSshKeyFromAgent o) => IsCredSshKeyFromAgent o +instance O.HasParentTypes CredSshKeyFromAgent +#if ENABLE_OVERLOADING +data CredSshKeyFromAgentUsernamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CredSshKeyFromAgentGetUsernameMethodInfo +#endif diff --git a/GI/Ggit/Objects/Diff.hs b/GI/Ggit/Objects/Diff.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Diff.hs @@ -0,0 +1,831 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a diff list. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Diff + ( +#if ENABLE_OVERLOADING + DiffForeachMethodInfo , +#endif +#if ENABLE_OVERLOADING + DiffBlobToBufferMethodInfo , +#endif +#if ENABLE_OVERLOADING + DiffBlobsMethodInfo , +#endif + +-- * Exported types + Diff(..) , + IsDiff , + toDiff , + noDiff , + + + -- * Methods +-- ** findSimilar #method:findSimilar# + +#if ENABLE_OVERLOADING + DiffFindSimilarMethodInfo , +#endif + diffFindSimilar , + + +-- ** formatEmail #method:formatEmail# + +#if ENABLE_OVERLOADING + DiffFormatEmailMethodInfo , +#endif + diffFormatEmail , + + +-- ** getDelta #method:getDelta# + +#if ENABLE_OVERLOADING + DiffGetDeltaMethodInfo , +#endif + diffGetDelta , + + +-- ** getNumDeltas #method:getNumDeltas# + +#if ENABLE_OVERLOADING + DiffGetNumDeltasMethodInfo , +#endif + diffGetNumDeltas , + + +-- ** merge #method:merge# + +#if ENABLE_OVERLOADING + DiffMergeMethodInfo , +#endif + diffMerge , + + +-- ** newIndexToWorkdir #method:newIndexToWorkdir# + + diffNewIndexToWorkdir , + + +-- ** newTreeToIndex #method:newTreeToIndex# + + diffNewTreeToIndex , + + +-- ** newTreeToTree #method:newTreeToTree# + + diffNewTreeToTree , + + +-- ** newTreeToWorkdir #method:newTreeToWorkdir# + + diffNewTreeToWorkdir , + + +-- ** print #method:print# + +#if ENABLE_OVERLOADING + DiffPrintMethodInfo , +#endif + diffPrint , + + + + + -- * Properties +-- ** repository #attr:repository# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffRepositoryPropertyInfo , +#endif + constructDiffRepository , +#if ENABLE_OVERLOADING + diffRepository , +#endif + getDiffRepository , + + + + + ) 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 qualified GI.Ggit.Callbacks as Ggit.Callbacks +import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Objects.DiffFindOptions as Ggit.DiffFindOptions +import {-# SOURCE #-} qualified GI.Ggit.Objects.DiffFormatEmailOptions as Ggit.DiffFormatEmailOptions +import {-# SOURCE #-} qualified GI.Ggit.Objects.DiffOptions as Ggit.DiffOptions +import {-# SOURCE #-} qualified GI.Ggit.Objects.Index as Ggit.Index +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.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Objects.Tree as Ggit.Tree +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffDelta as Ggit.DiffDelta + +-- | Memory-managed wrapper type. +newtype Diff = Diff (ManagedPtr Diff) +foreign import ccall "ggit_diff_get_type" + c_ggit_diff_get_type :: IO GType + +instance GObject Diff where + gobjectType = c_ggit_diff_get_type + + +-- | Type class for types which can be safely cast to `Diff`, for instance with `toDiff`. +class (GObject o, O.IsDescendantOf Diff o) => IsDiff o +instance (GObject o, O.IsDescendantOf Diff o) => IsDiff o + +instance O.HasParentTypes Diff +type instance O.ParentTypes Diff = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Diff`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDiff :: (MonadIO m, IsDiff o) => o -> m Diff +toDiff = liftIO . unsafeCastTo Diff + +-- | A convenience alias for `Nothing` :: `Maybe` `Diff`. +noDiff :: Maybe Diff +noDiff = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDiffMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDiffMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDiffMethod "findSimilar" o = DiffFindSimilarMethodInfo + ResolveDiffMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDiffMethod "foreach" o = DiffForeachMethodInfo + ResolveDiffMethod "formatEmail" o = DiffFormatEmailMethodInfo + ResolveDiffMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDiffMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDiffMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDiffMethod "merge" o = DiffMergeMethodInfo + ResolveDiffMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDiffMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDiffMethod "print" o = DiffPrintMethodInfo + ResolveDiffMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDiffMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDiffMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDiffMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDiffMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDiffMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDiffMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDiffMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDiffMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDiffMethod "getDelta" o = DiffGetDeltaMethodInfo + ResolveDiffMethod "getNumDeltas" o = DiffGetNumDeltasMethodInfo + ResolveDiffMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDiffMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDiffMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDiffMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDiffMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffMethod t Diff, O.MethodInfo info Diff p) => OL.IsLabel t (Diff -> 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 + +-- VVV Prop "repository" + -- Type: TInterface (Name {namespace = "Ggit", name = "Repository"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@repository@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diff #repository +@ +-} +getDiffRepository :: (MonadIO m, IsDiff o) => o -> m (Maybe Ggit.Repository.Repository) +getDiffRepository obj = liftIO $ B.Properties.getObjectPropertyObject obj "repository" Ggit.Repository.Repository + +{- | +Construct a `GValueConstruct` with valid value for the “@repository@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffRepository :: (IsDiff o, Ggit.Repository.IsRepository a) => a -> IO (GValueConstruct o) +constructDiffRepository val = B.Properties.constructObjectPropertyObject "repository" (Just val) + +#if ENABLE_OVERLOADING +data DiffRepositoryPropertyInfo +instance AttrInfo DiffRepositoryPropertyInfo where + type AttrAllowedOps DiffRepositoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffRepositoryPropertyInfo = Ggit.Repository.IsRepository + type AttrBaseTypeConstraint DiffRepositoryPropertyInfo = IsDiff + type AttrGetType DiffRepositoryPropertyInfo = (Maybe Ggit.Repository.Repository) + type AttrLabel DiffRepositoryPropertyInfo = "repository" + type AttrOrigin DiffRepositoryPropertyInfo = Diff + attrGet _ = getDiffRepository + attrSet _ = undefined + attrConstruct _ = constructDiffRepository + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Diff +type instance O.AttributeList Diff = DiffAttributeList +type DiffAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo), '("repository", DiffRepositoryPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +diffRepository :: AttrLabelProxy "repository" +diffRepository = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Diff = DiffSignalList +type DiffSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Diff::new_index_to_workdir +-- method type : Constructor +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitIndex, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff_options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Diff"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_new_index_to_workdir" ggit_diff_new_index_to_workdir :: + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Index.Index -> -- index : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr Ggit.DiffOptions.DiffOptions -> -- diff_options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Diff) + +{- | +Creates a 'GI.Ggit.Objects.Diff.Diff' which compares the working directory and the index. + +If /@index@/ is 'Nothing' then /@repository@/ index is used. +If /@diffOptions@/ is 'Nothing' then the defaults specified in +'GI.Ggit.Objects.DiffOptions.diffOptionsNew' are used. +-} +diffNewIndexToWorkdir :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a, Ggit.Index.IsIndex b, Ggit.DiffOptions.IsDiffOptions c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@index@/: a 'GI.Ggit.Objects.Index.Index', or 'Nothing'. -} + -> Maybe (c) + {- ^ /@diffOptions@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions', or 'Nothing'. -} + -> m (Maybe Diff) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Diff.Diff' if +there was no error, 'Nothing' otherwise. /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffNewIndexToWorkdir repository index diffOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeIndex <- case index of + Nothing -> return nullPtr + Just jIndex -> do + jIndex' <- unsafeManagedPtrCastPtr jIndex + return jIndex' + maybeDiffOptions <- case diffOptions of + Nothing -> return nullPtr + Just jDiffOptions -> do + jDiffOptions' <- unsafeManagedPtrCastPtr jDiffOptions + return jDiffOptions' + onException (do + result <- propagateGError $ ggit_diff_new_index_to_workdir repository' maybeIndex maybeDiffOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Diff) result' + return result'' + touchManagedPtr repository + whenJust index touchManagedPtr + whenJust diffOptions touchManagedPtr + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Diff::new_tree_to_index +-- method type : Constructor +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitTree to diff from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitIndex, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff_options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Diff"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_new_tree_to_index" ggit_diff_new_tree_to_index :: + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Tree.Tree -> -- old_tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr Ggit.Index.Index -> -- index : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr Ggit.DiffOptions.DiffOptions -> -- diff_options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Diff) + +{- | +Creates a 'GI.Ggit.Objects.Diff.Diff' which compares /@oldTree@/ and the index. + +If /@index@/ is 'Nothing' then /@repository@/ index is used. +If /@diffOptions@/ is 'Nothing' then the defaults specified in +'GI.Ggit.Objects.DiffOptions.diffOptionsNew' are used. +-} +diffNewTreeToIndex :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a, Ggit.Tree.IsTree b, Ggit.Index.IsIndex c, Ggit.DiffOptions.IsDiffOptions d) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@oldTree@/: a 'GI.Ggit.Objects.Tree.Tree' to diff from. -} + -> Maybe (c) + {- ^ /@index@/: a 'GI.Ggit.Objects.Index.Index', or 'Nothing'. -} + -> Maybe (d) + {- ^ /@diffOptions@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions', or 'Nothing'. -} + -> m (Maybe Diff) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Diff.Diff' if +there was no error, 'Nothing' otherwise. /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffNewTreeToIndex repository oldTree index diffOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeOldTree <- case oldTree of + Nothing -> return nullPtr + Just jOldTree -> do + jOldTree' <- unsafeManagedPtrCastPtr jOldTree + return jOldTree' + maybeIndex <- case index of + Nothing -> return nullPtr + Just jIndex -> do + jIndex' <- unsafeManagedPtrCastPtr jIndex + return jIndex' + maybeDiffOptions <- case diffOptions of + Nothing -> return nullPtr + Just jDiffOptions -> do + jDiffOptions' <- unsafeManagedPtrCastPtr jDiffOptions + return jDiffOptions' + onException (do + result <- propagateGError $ ggit_diff_new_tree_to_index repository' maybeOldTree maybeIndex maybeDiffOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Diff) result' + return result'' + touchManagedPtr repository + whenJust oldTree touchManagedPtr + whenJust index touchManagedPtr + whenJust diffOptions touchManagedPtr + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Diff::new_tree_to_tree +-- method type : Constructor +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitTree to diff from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitTree to diff to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff_options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Diff"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_new_tree_to_tree" ggit_diff_new_tree_to_tree :: + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Tree.Tree -> -- old_tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr Ggit.Tree.Tree -> -- new_tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr Ggit.DiffOptions.DiffOptions -> -- diff_options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Diff) + +{- | +Creates a 'GI.Ggit.Objects.Diff.Diff' which compares /@oldTree@/ and /@newTree@/. + +If /@diffOptions@/ is 'Nothing' then the defaults specified in +'GI.Ggit.Objects.DiffOptions.diffOptionsNew' are used. +-} +diffNewTreeToTree :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a, Ggit.Tree.IsTree b, Ggit.Tree.IsTree c, Ggit.DiffOptions.IsDiffOptions d) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@oldTree@/: a 'GI.Ggit.Objects.Tree.Tree' to diff from. -} + -> Maybe (c) + {- ^ /@newTree@/: a 'GI.Ggit.Objects.Tree.Tree' to diff to. -} + -> Maybe (d) + {- ^ /@diffOptions@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions', or 'Nothing'. -} + -> m (Maybe Diff) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Diff.Diff' if +there was no error, 'Nothing' otherwise. /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffNewTreeToTree repository oldTree newTree diffOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeOldTree <- case oldTree of + Nothing -> return nullPtr + Just jOldTree -> do + jOldTree' <- unsafeManagedPtrCastPtr jOldTree + return jOldTree' + maybeNewTree <- case newTree of + Nothing -> return nullPtr + Just jNewTree -> do + jNewTree' <- unsafeManagedPtrCastPtr jNewTree + return jNewTree' + maybeDiffOptions <- case diffOptions of + Nothing -> return nullPtr + Just jDiffOptions -> do + jDiffOptions' <- unsafeManagedPtrCastPtr jDiffOptions + return jDiffOptions' + onException (do + result <- propagateGError $ ggit_diff_new_tree_to_tree repository' maybeOldTree maybeNewTree maybeDiffOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Diff) result' + return result'' + touchManagedPtr repository + whenJust oldTree touchManagedPtr + whenJust newTree touchManagedPtr + whenJust diffOptions touchManagedPtr + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Diff::new_tree_to_workdir +-- method type : Constructor +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitTree to diff from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff_options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Diff"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_new_tree_to_workdir" ggit_diff_new_tree_to_workdir :: + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Tree.Tree -> -- old_tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr Ggit.DiffOptions.DiffOptions -> -- diff_options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Diff) + +{- | +Creates a 'GI.Ggit.Objects.Diff.Diff' which compares the working directory and /@oldTree@/. + +If /@diffOptions@/ is 'Nothing' then the defaults specified in +'GI.Ggit.Objects.DiffOptions.diffOptionsNew' are used. +-} +diffNewTreeToWorkdir :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a, Ggit.Tree.IsTree b, Ggit.DiffOptions.IsDiffOptions c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@oldTree@/: a 'GI.Ggit.Objects.Tree.Tree' to diff from. -} + -> Maybe (c) + {- ^ /@diffOptions@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions', or 'Nothing'. -} + -> m (Maybe Diff) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Diff.Diff' if +there was no error, 'Nothing' otherwise. /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffNewTreeToWorkdir repository oldTree diffOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeOldTree <- case oldTree of + Nothing -> return nullPtr + Just jOldTree -> do + jOldTree' <- unsafeManagedPtrCastPtr jOldTree + return jOldTree' + maybeDiffOptions <- case diffOptions of + Nothing -> return nullPtr + Just jDiffOptions -> do + jDiffOptions' <- unsafeManagedPtrCastPtr jDiffOptions + return jDiffOptions' + onException (do + result <- propagateGError $ ggit_diff_new_tree_to_workdir repository' maybeOldTree maybeDiffOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Diff) result' + return result'' + touchManagedPtr repository + whenJust oldTree touchManagedPtr + whenJust diffOptions touchManagedPtr + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Diff::find_similar +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "diff", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiff.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_find_similar" ggit_diff_find_similar :: + Ptr Diff -> -- diff : TInterface (Name {namespace = "Ggit", name = "Diff"}) + Ptr Ggit.DiffFindOptions.DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Transform /@diff@/ marking file renames, copies, etc.. If /@options@/ is set to +'Nothing', then the default options will be used. +-} +diffFindSimilar :: + (B.CallStack.HasCallStack, MonadIO m, IsDiff a, Ggit.DiffFindOptions.IsDiffFindOptions b) => + a + {- ^ /@diff@/: a 'GI.Ggit.Objects.Diff.Diff'. -} + -> Maybe (b) + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions' or 'Nothing'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffFindSimilar diff options = liftIO $ do + diff' <- unsafeManagedPtrCastPtr diff + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrCastPtr jOptions + return jOptions' + onException (do + _ <- propagateGError $ ggit_diff_find_similar diff' maybeOptions + touchManagedPtr diff + whenJust options touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data DiffFindSimilarMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDiff a, Ggit.DiffFindOptions.IsDiffFindOptions b) => O.MethodInfo DiffFindSimilarMethodInfo a signature where + overloadedMethod _ = diffFindSimilar + +#endif + +-- XXX Could not generate method Diff::foreach +-- Error was : Not implemented: "Closure for multiple callbacks unsupportedArg\n { argCName = \"binary_cb\"\n , argType =\n TInterface\n Name { namespace = \"Ggit\" , name = \"DiffBinaryCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffBinaryCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 5\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\nCallable\n { returnType = Nothing\n , returnMayBeNull = False\n , returnTransfer = TransferNothing\n , returnDocumentation =\n Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n , args =\n [ Arg\n { argCName = \"diff\"\n , argType = TInterface Name { namespace = \"Ggit\" , name = \"Diff\" }\n , direction = DirectionIn\n , mayBeNull = False\n , argDoc =\n Documentation\n { rawDocText = Just \"a #GgitDiff.\" , sinceVersion = Nothing }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"file_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffFileCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffFileCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 5\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"binary_cb\"\n , argType =\n TInterface\n Name { namespace = \"Ggit\" , name = \"DiffBinaryCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffBinaryCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 5\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"hunk_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffHunkCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffHunkCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 5\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"line_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffLineCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffLineCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 5\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"user_data\"\n , argType = TBasicType TPtr\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"callback user data.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n ]\n , skipReturn = False\n , callableThrows = True\n , callableDeprecated = Nothing\n , callableDocumentation =\n Documentation\n { rawDocText =\n Just\n \"Iterates over the diff calling @file_cb, @binary_cb, @hunk_cb and @line_cb.\"\n , sinceVersion = Nothing\n }\n }" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data DiffForeachMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "foreach" Diff) => O.MethodInfo DiffForeachMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method Diff::format_email +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "diff", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiff.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_format_email" ggit_diff_format_email :: + Ptr Diff -> -- diff : TInterface (Name {namespace = "Ggit", name = "Diff"}) + Ptr Ggit.DiffFormatEmailOptions.DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + Ptr (Ptr GError) -> -- error + IO CString + +{- | +Create an e-mail ready patch from a diff. +-} +diffFormatEmail :: + (B.CallStack.HasCallStack, MonadIO m, IsDiff a, Ggit.DiffFormatEmailOptions.IsDiffFormatEmailOptions b) => + a + {- ^ /@diff@/: a 'GI.Ggit.Objects.Diff.Diff'. -} + -> b + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the patch or 'Nothing' if an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffFormatEmail diff options = liftIO $ do + diff' <- unsafeManagedPtrCastPtr diff + options' <- unsafeManagedPtrCastPtr options + onException (do + result <- propagateGError $ ggit_diff_format_email diff' options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr diff + touchManagedPtr options + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data DiffFormatEmailMethodInfo +instance (signature ~ (b -> m (Maybe T.Text)), MonadIO m, IsDiff a, Ggit.DiffFormatEmailOptions.IsDiffFormatEmailOptions b) => O.MethodInfo DiffFormatEmailMethodInfo a signature where + overloadedMethod _ = diffFormatEmail + +#endif + +-- method Diff::get_delta +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "diff", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiff.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffDelta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_get_delta" ggit_diff_get_delta :: + Ptr Diff -> -- diff : TInterface (Name {namespace = "Ggit", name = "Diff"}) + Word64 -> -- index : TBasicType TUInt64 + IO (Ptr Ggit.DiffDelta.DiffDelta) + +{- | +Get the delta at the specified index. +-} +diffGetDelta :: + (B.CallStack.HasCallStack, MonadIO m, IsDiff a) => + a + {- ^ /@diff@/: a 'GI.Ggit.Objects.Diff.Diff'. -} + -> Word64 + {- ^ /@index@/: the index. -} + -> m (Maybe Ggit.DiffDelta.DiffDelta) + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffDelta.DiffDelta' or 'Nothing'. -} +diffGetDelta diff index = liftIO $ do + diff' <- unsafeManagedPtrCastPtr diff + result <- ggit_diff_get_delta diff' index + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.DiffDelta.DiffDelta) result' + return result'' + touchManagedPtr diff + return maybeResult + +#if ENABLE_OVERLOADING +data DiffGetDeltaMethodInfo +instance (signature ~ (Word64 -> m (Maybe Ggit.DiffDelta.DiffDelta)), MonadIO m, IsDiff a) => O.MethodInfo DiffGetDeltaMethodInfo a signature where + overloadedMethod _ = diffGetDelta + +#endif + +-- method Diff::get_num_deltas +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "diff", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), 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 (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_get_num_deltas" ggit_diff_get_num_deltas :: + Ptr Diff -> -- diff : TInterface (Name {namespace = "Ggit", name = "Diff"}) + IO Word64 + +{- | +Get the number of deltas in the diff. +-} +diffGetNumDeltas :: + (B.CallStack.HasCallStack, MonadIO m, IsDiff a) => + a + {- ^ /@diff@/: a 'GI.Ggit.Objects.Diff.Diff'. -} + -> m Word64 + {- ^ __Returns:__ the number of deltas. -} +diffGetNumDeltas diff = liftIO $ do + diff' <- unsafeManagedPtrCastPtr diff + result <- ggit_diff_get_num_deltas diff' + touchManagedPtr diff + return result + +#if ENABLE_OVERLOADING +data DiffGetNumDeltasMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsDiff a) => O.MethodInfo DiffGetNumDeltasMethodInfo a signature where + overloadedMethod _ = diffGetNumDeltas + +#endif + +-- method Diff::merge +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "onto", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GgitDiff to merge into.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GgitDiff to merge.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_merge" ggit_diff_merge :: + Ptr Diff -> -- onto : TInterface (Name {namespace = "Ggit", name = "Diff"}) + Ptr Diff -> -- from : TInterface (Name {namespace = "Ggit", name = "Diff"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Merges /@from@/ into /@onto@/ unless /@error@/ is set. +-} +diffMerge :: + (B.CallStack.HasCallStack, MonadIO m, IsDiff a, IsDiff b) => + a + {- ^ /@onto@/: the 'GI.Ggit.Objects.Diff.Diff' to merge into. -} + -> b + {- ^ /@from@/: the 'GI.Ggit.Objects.Diff.Diff' to merge. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffMerge onto from = liftIO $ do + onto' <- unsafeManagedPtrCastPtr onto + from' <- unsafeManagedPtrCastPtr from + onException (do + propagateGError $ ggit_diff_merge onto' from' + touchManagedPtr onto + touchManagedPtr from + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data DiffMergeMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsDiff a, IsDiff b) => O.MethodInfo DiffMergeMethodInfo a signature where + overloadedMethod _ = diffMerge + +#endif + +-- method Diff::print +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "diff", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiff.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatType.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "print_cb", argType = TInterface (Name {namespace = "Ggit", name = "DiffLineCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLineCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_diff_print" ggit_diff_print :: + Ptr Diff -> -- diff : TInterface (Name {namespace = "Ggit", name = "Diff"}) + CUInt -> -- type : TInterface (Name {namespace = "Ggit", name = "DiffFormatType"}) + FunPtr Ggit.Callbacks.C_DiffLineCallback -> -- print_cb : TInterface (Name {namespace = "Ggit", name = "DiffLineCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO () + +{- | +Iterates over /@diff@/ generating text output like \"git diff\". +-} +diffPrint :: + (B.CallStack.HasCallStack, MonadIO m, IsDiff a) => + a + {- ^ /@diff@/: a 'GI.Ggit.Objects.Diff.Diff'. -} + -> Ggit.Enums.DiffFormatType + {- ^ /@type@/: a 'GI.Ggit.Enums.DiffFormatType'. -} + -> Ggit.Callbacks.DiffLineCallback + {- ^ /@printCb@/: a 'GI.Ggit.Callbacks.DiffLineCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +diffPrint diff type_ printCb = liftIO $ do + diff' <- unsafeManagedPtrCastPtr diff + let type_' = (fromIntegral . fromEnum) type_ + printCb' <- Ggit.Callbacks.mk_DiffLineCallback (Ggit.Callbacks.wrap_DiffLineCallback Nothing (Ggit.Callbacks.drop_closures_DiffLineCallback printCb)) + let userData = nullPtr + onException (do + propagateGError $ ggit_diff_print diff' type_' printCb' userData + safeFreeFunPtr $ castFunPtrToPtr printCb' + touchManagedPtr diff + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr printCb' + return () + ) + +#if ENABLE_OVERLOADING +data DiffPrintMethodInfo +instance (signature ~ (Ggit.Enums.DiffFormatType -> Ggit.Callbacks.DiffLineCallback -> m ()), MonadIO m, IsDiff a) => O.MethodInfo DiffPrintMethodInfo a signature where + overloadedMethod _ = diffPrint + +#endif + +-- XXX Could not generate method Diff::blob_to_buffer +-- Error was : Not implemented: "Closure for multiple callbacks unsupportedArg\n { argCName = \"binary_cb\"\n , argType =\n TInterface\n Name { namespace = \"Ggit\" , name = \"DiffBinaryCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffBinaryCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 10\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\nCallable\n { returnType = Nothing\n , returnMayBeNull = False\n , returnTransfer = TransferNothing\n , returnDocumentation =\n Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n , args =\n [ Arg\n { argCName = \"old_blob\"\n , argType = TInterface Name { namespace = \"Ggit\" , name = \"Blob\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"a #GgitBlob to diff from.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"old_as_path\"\n , argType = TBasicType TUTF8\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText =\n Just \"treat @old_blob as if it had this filename, or %NULL,\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"buffer\"\n , argType = TCArray False (-1) 3 (TBasicType TUInt8)\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"a buffer to diff to.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"buffer_len\"\n , argType = TBasicType TInt64\n , direction = DirectionIn\n , mayBeNull = False\n , argDoc =\n Documentation\n { rawDocText = Just \"length of @buffer.\" , sinceVersion = Nothing }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"buffer_as_path\"\n , argType = TBasicType TUTF8\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText =\n Just \"treat @buffer as if it had this filename, or %NULL,\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"diff_options\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffOptions\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"a #GgitDiffOptions, or %NULL.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"file_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffFileCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffFileCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 10\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"binary_cb\"\n , argType =\n TInterface\n Name { namespace = \"Ggit\" , name = \"DiffBinaryCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffBinaryCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 10\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"hunk_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffHunkCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffHunkCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 10\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"line_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffLineCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffLineCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 10\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"user_data\"\n , argType = TBasicType TPtr\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"callback user data.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n ]\n , skipReturn = False\n , callableThrows = True\n , callableDeprecated = Nothing\n , callableDocumentation =\n Documentation\n { rawDocText = Just \"Same as ggit_diff_blobs() but using a buffer.\"\n , sinceVersion = Nothing\n }\n }" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data DiffBlobToBufferMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "blobToBuffer" Diff) => O.MethodInfo DiffBlobToBufferMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- XXX Could not generate method Diff::blobs +-- Error was : Not implemented: "Closure for multiple callbacks unsupportedArg\n { argCName = \"binary_cb\"\n , argType =\n TInterface\n Name { namespace = \"Ggit\" , name = \"DiffBinaryCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffBinaryCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 9\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\nCallable\n { returnType = Nothing\n , returnMayBeNull = False\n , returnTransfer = TransferNothing\n , returnDocumentation =\n Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n , args =\n [ Arg\n { argCName = \"old_blob\"\n , argType = TInterface Name { namespace = \"Ggit\" , name = \"Blob\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"a #GgitBlob to diff from.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"old_as_path\"\n , argType = TBasicType TUTF8\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText =\n Just \"treat @old_blob as if it had this filename, or %NULL,\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"new_blob\"\n , argType = TInterface Name { namespace = \"Ggit\" , name = \"Blob\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"a #GgitBlob to diff to.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"new_as_path\"\n , argType = TBasicType TUTF8\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText =\n Just \"treat @new_blob as if it had this filename, or %NULL,\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"diff_options\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffOptions\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"a #GgitDiffOptions, or %NULL.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"file_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffFileCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffFileCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 9\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"binary_cb\"\n , argType =\n TInterface\n Name { namespace = \"Ggit\" , name = \"DiffBinaryCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffBinaryCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 9\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"hunk_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffHunkCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffHunkCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 9\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"line_cb\"\n , argType =\n TInterface Name { namespace = \"Ggit\" , name = \"DiffLineCallback\" }\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"\\n a #GgitDiffLineCallback.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeCall\n , argClosure = 9\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n , Arg\n { argCName = \"user_data\"\n , argType = TBasicType TPtr\n , direction = DirectionIn\n , mayBeNull = True\n , argDoc =\n Documentation\n { rawDocText = Just \"callback user data.\"\n , sinceVersion = Nothing\n }\n , argScope = ScopeTypeInvalid\n , argClosure = -1\n , argDestroy = -1\n , argCallerAllocates = False\n , transfer = TransferNothing\n }\n ]\n , skipReturn = False\n , callableThrows = True\n , callableDeprecated = Nothing\n , callableDocumentation =\n Documentation\n { rawDocText =\n Just\n \"Iterates over the diff calling @file_cb, @binary_cb, @hunk_cb and @line_cb.\\n\\nThe #GgitDiffFile mode always be 0, path will be %NULL and when a blob is\\n%NULL the oid will be 0.\\n\\nIf @diff_options is %NULL then the defaults specified in\\nggit_diff_options_new() are used.\"\n , sinceVersion = Nothing\n }\n }" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data DiffBlobsMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "blobs" Diff) => O.MethodInfo DiffBlobsMethodInfo o p where + overloadedMethod _ = undefined +#endif + + diff --git a/GI/Ggit/Objects/Diff.hs-boot b/GI/Ggit/Objects/Diff.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Diff.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Diff 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 + +newtype Diff = Diff (ManagedPtr Diff) +instance GObject Diff where +class (GObject o, O.IsDescendantOf Diff o) => IsDiff o +instance (GObject o, O.IsDescendantOf Diff o) => IsDiff o +instance O.HasParentTypes Diff +#if ENABLE_OVERLOADING +data DiffRepositoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindSimilarMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffGetDeltaMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffGetNumDeltasMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffMergeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffPrintMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBlobToBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBlobsMethodInfo +#endif diff --git a/GI/Ggit/Objects/DiffFindOptions.hs b/GI/Ggit/Objects/DiffFindOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/DiffFindOptions.hs @@ -0,0 +1,1087 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents options for finding diff similarity. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.DiffFindOptions + ( + +-- * Exported types + DiffFindOptions(..) , + IsDiffFindOptions , + toDiffFindOptions , + noDiffFindOptions , + + + -- * Methods +-- ** getCopyThreshold #method:getCopyThreshold# + +#if ENABLE_OVERLOADING + DiffFindOptionsGetCopyThresholdMethodInfo, +#endif + diffFindOptionsGetCopyThreshold , + + +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + DiffFindOptionsGetFlagsMethodInfo , +#endif + diffFindOptionsGetFlags , + + +-- ** getMetric #method:getMetric# + +#if ENABLE_OVERLOADING + DiffFindOptionsGetMetricMethodInfo , +#endif + diffFindOptionsGetMetric , + + +-- ** getRenameFromRewriteThreshold #method:getRenameFromRewriteThreshold# + +#if ENABLE_OVERLOADING + DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo, +#endif + diffFindOptionsGetRenameFromRewriteThreshold, + + +-- ** getRenameLimit #method:getRenameLimit# + +#if ENABLE_OVERLOADING + DiffFindOptionsGetRenameLimitMethodInfo , +#endif + diffFindOptionsGetRenameLimit , + + +-- ** getRenameThreshold #method:getRenameThreshold# + +#if ENABLE_OVERLOADING + DiffFindOptionsGetRenameThresholdMethodInfo, +#endif + diffFindOptionsGetRenameThreshold , + + +-- ** new #method:new# + + diffFindOptionsNew , + + +-- ** setCopyThreshold #method:setCopyThreshold# + +#if ENABLE_OVERLOADING + DiffFindOptionsSetCopyThresholdMethodInfo, +#endif + diffFindOptionsSetCopyThreshold , + + +-- ** setFlags #method:setFlags# + +#if ENABLE_OVERLOADING + DiffFindOptionsSetFlagsMethodInfo , +#endif + diffFindOptionsSetFlags , + + +-- ** setMetric #method:setMetric# + +#if ENABLE_OVERLOADING + DiffFindOptionsSetMetricMethodInfo , +#endif + diffFindOptionsSetMetric , + + +-- ** setRenameFromRewriteThreshold #method:setRenameFromRewriteThreshold# + +#if ENABLE_OVERLOADING + DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo, +#endif + diffFindOptionsSetRenameFromRewriteThreshold, + + +-- ** setRenameLimit #method:setRenameLimit# + +#if ENABLE_OVERLOADING + DiffFindOptionsSetRenameLimitMethodInfo , +#endif + diffFindOptionsSetRenameLimit , + + +-- ** setRenameThreshold #method:setRenameThreshold# + +#if ENABLE_OVERLOADING + DiffFindOptionsSetRenameThresholdMethodInfo, +#endif + diffFindOptionsSetRenameThreshold , + + + + + -- * Properties +-- ** copyThreshold #attr:copyThreshold# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFindOptionsCopyThresholdPropertyInfo, +#endif + constructDiffFindOptionsCopyThreshold , +#if ENABLE_OVERLOADING + diffFindOptionsCopyThreshold , +#endif + getDiffFindOptionsCopyThreshold , + setDiffFindOptionsCopyThreshold , + + +-- ** flags #attr:flags# +{- | The diff option flags. +-} +#if ENABLE_OVERLOADING + DiffFindOptionsFlagsPropertyInfo , +#endif + constructDiffFindOptionsFlags , +#if ENABLE_OVERLOADING + diffFindOptionsFlags , +#endif + getDiffFindOptionsFlags , + setDiffFindOptionsFlags , + + +-- ** metric #attr:metric# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFindOptionsMetricPropertyInfo , +#endif + constructDiffFindOptionsMetric , +#if ENABLE_OVERLOADING + diffFindOptionsMetric , +#endif + getDiffFindOptionsMetric , + setDiffFindOptionsMetric , + + +-- ** renameFromRewriteThreshold #attr:renameFromRewriteThreshold# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFindOptionsRenameFromRewriteThresholdPropertyInfo, +#endif + constructDiffFindOptionsRenameFromRewriteThreshold, +#if ENABLE_OVERLOADING + diffFindOptionsRenameFromRewriteThreshold, +#endif + getDiffFindOptionsRenameFromRewriteThreshold, + setDiffFindOptionsRenameFromRewriteThreshold, + + +-- ** renameLimit #attr:renameLimit# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFindOptionsRenameLimitPropertyInfo , +#endif + constructDiffFindOptionsRenameLimit , +#if ENABLE_OVERLOADING + diffFindOptionsRenameLimit , +#endif + getDiffFindOptionsRenameLimit , + setDiffFindOptionsRenameLimit , + + +-- ** renameThreshold #attr:renameThreshold# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFindOptionsRenameThresholdPropertyInfo, +#endif + constructDiffFindOptionsRenameThreshold , +#if ENABLE_OVERLOADING + diffFindOptionsRenameThreshold , +#endif + getDiffFindOptionsRenameThreshold , + setDiffFindOptionsRenameThreshold , + + + + + ) 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.Structs.DiffSimilarityMetric as Ggit.DiffSimilarityMetric + +-- | Memory-managed wrapper type. +newtype DiffFindOptions = DiffFindOptions (ManagedPtr DiffFindOptions) +foreign import ccall "ggit_diff_find_options_get_type" + c_ggit_diff_find_options_get_type :: IO GType + +instance GObject DiffFindOptions where + gobjectType = c_ggit_diff_find_options_get_type + + +-- | Type class for types which can be safely cast to `DiffFindOptions`, for instance with `toDiffFindOptions`. +class (GObject o, O.IsDescendantOf DiffFindOptions o) => IsDiffFindOptions o +instance (GObject o, O.IsDescendantOf DiffFindOptions o) => IsDiffFindOptions o + +instance O.HasParentTypes DiffFindOptions +type instance O.ParentTypes DiffFindOptions = '[GObject.Object.Object] + +-- | Cast to `DiffFindOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDiffFindOptions :: (MonadIO m, IsDiffFindOptions o) => o -> m DiffFindOptions +toDiffFindOptions = liftIO . unsafeCastTo DiffFindOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffFindOptions`. +noDiffFindOptions :: Maybe DiffFindOptions +noDiffFindOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDiffFindOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffFindOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDiffFindOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDiffFindOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDiffFindOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDiffFindOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDiffFindOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDiffFindOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDiffFindOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDiffFindOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDiffFindOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDiffFindOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDiffFindOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDiffFindOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDiffFindOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDiffFindOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDiffFindOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDiffFindOptionsMethod "getCopyThreshold" o = DiffFindOptionsGetCopyThresholdMethodInfo + ResolveDiffFindOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDiffFindOptionsMethod "getFlags" o = DiffFindOptionsGetFlagsMethodInfo + ResolveDiffFindOptionsMethod "getMetric" o = DiffFindOptionsGetMetricMethodInfo + ResolveDiffFindOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDiffFindOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDiffFindOptionsMethod "getRenameFromRewriteThreshold" o = DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo + ResolveDiffFindOptionsMethod "getRenameLimit" o = DiffFindOptionsGetRenameLimitMethodInfo + ResolveDiffFindOptionsMethod "getRenameThreshold" o = DiffFindOptionsGetRenameThresholdMethodInfo + ResolveDiffFindOptionsMethod "setCopyThreshold" o = DiffFindOptionsSetCopyThresholdMethodInfo + ResolveDiffFindOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDiffFindOptionsMethod "setFlags" o = DiffFindOptionsSetFlagsMethodInfo + ResolveDiffFindOptionsMethod "setMetric" o = DiffFindOptionsSetMetricMethodInfo + ResolveDiffFindOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDiffFindOptionsMethod "setRenameFromRewriteThreshold" o = DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo + ResolveDiffFindOptionsMethod "setRenameLimit" o = DiffFindOptionsSetRenameLimitMethodInfo + ResolveDiffFindOptionsMethod "setRenameThreshold" o = DiffFindOptionsSetRenameThresholdMethodInfo + ResolveDiffFindOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffFindOptionsMethod t DiffFindOptions, O.MethodInfo info DiffFindOptions p) => OL.IsLabel t (DiffFindOptions -> 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 + +-- VVV Prop "copy-threshold" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@copy-threshold@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFindOptions #copyThreshold +@ +-} +getDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32 +getDiffFindOptionsCopyThreshold obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "copy-threshold" + +{- | +Set the value of the “@copy-threshold@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFindOptions [ #copyThreshold 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m () +setDiffFindOptionsCopyThreshold obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "copy-threshold" val + +{- | +Construct a `GValueConstruct` with valid value for the “@copy-threshold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFindOptionsCopyThreshold :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o) +constructDiffFindOptionsCopyThreshold val = B.Properties.constructObjectPropertyUInt32 "copy-threshold" val + +#if ENABLE_OVERLOADING +data DiffFindOptionsCopyThresholdPropertyInfo +instance AttrInfo DiffFindOptionsCopyThresholdPropertyInfo where + type AttrAllowedOps DiffFindOptionsCopyThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint DiffFindOptionsCopyThresholdPropertyInfo = IsDiffFindOptions + type AttrGetType DiffFindOptionsCopyThresholdPropertyInfo = Word32 + type AttrLabel DiffFindOptionsCopyThresholdPropertyInfo = "copy-threshold" + type AttrOrigin DiffFindOptionsCopyThresholdPropertyInfo = DiffFindOptions + attrGet _ = getDiffFindOptionsCopyThreshold + attrSet _ = setDiffFindOptionsCopyThreshold + attrConstruct _ = constructDiffFindOptionsCopyThreshold + attrClear _ = undefined +#endif + +-- VVV Prop "flags" + -- Type: TInterface (Name {namespace = "Ggit", name = "DiffFindFlags"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFindOptions #flags +@ +-} +getDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> m [Ggit.Flags.DiffFindFlags] +getDiffFindOptionsFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags" + +{- | +Set the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFindOptions [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> [Ggit.Flags.DiffFindFlags] -> m () +setDiffFindOptionsFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val + +{- | +Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFindOptionsFlags :: (IsDiffFindOptions o) => [Ggit.Flags.DiffFindFlags] -> IO (GValueConstruct o) +constructDiffFindOptionsFlags val = B.Properties.constructObjectPropertyFlags "flags" val + +#if ENABLE_OVERLOADING +data DiffFindOptionsFlagsPropertyInfo +instance AttrInfo DiffFindOptionsFlagsPropertyInfo where + type AttrAllowedOps DiffFindOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFindOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFindFlags] + type AttrBaseTypeConstraint DiffFindOptionsFlagsPropertyInfo = IsDiffFindOptions + type AttrGetType DiffFindOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFindFlags] + type AttrLabel DiffFindOptionsFlagsPropertyInfo = "flags" + type AttrOrigin DiffFindOptionsFlagsPropertyInfo = DiffFindOptions + attrGet _ = getDiffFindOptionsFlags + attrSet _ = setDiffFindOptionsFlags + attrConstruct _ = constructDiffFindOptionsFlags + attrClear _ = undefined +#endif + +-- VVV Prop "metric" + -- Type: TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just False) + +{- | +Get the value of the “@metric@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFindOptions #metric +@ +-} +getDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric) +getDiffFindOptionsMetric obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "metric" Ggit.DiffSimilarityMetric.DiffSimilarityMetric + +{- | +Set the value of the “@metric@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFindOptions [ #metric 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m () +setDiffFindOptionsMetric obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "metric" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@metric@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFindOptionsMetric :: (IsDiffFindOptions o) => Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> IO (GValueConstruct o) +constructDiffFindOptionsMetric val = B.Properties.constructObjectPropertyBoxed "metric" (Just val) + +#if ENABLE_OVERLOADING +data DiffFindOptionsMetricPropertyInfo +instance AttrInfo DiffFindOptionsMetricPropertyInfo where + type AttrAllowedOps DiffFindOptionsMetricPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFindOptionsMetricPropertyInfo = (~) Ggit.DiffSimilarityMetric.DiffSimilarityMetric + type AttrBaseTypeConstraint DiffFindOptionsMetricPropertyInfo = IsDiffFindOptions + type AttrGetType DiffFindOptionsMetricPropertyInfo = (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric) + type AttrLabel DiffFindOptionsMetricPropertyInfo = "metric" + type AttrOrigin DiffFindOptionsMetricPropertyInfo = DiffFindOptions + attrGet _ = getDiffFindOptionsMetric + attrSet _ = setDiffFindOptionsMetric + attrConstruct _ = constructDiffFindOptionsMetric + attrClear _ = undefined +#endif + +-- VVV Prop "rename-from-rewrite-threshold" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@rename-from-rewrite-threshold@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFindOptions #renameFromRewriteThreshold +@ +-} +getDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32 +getDiffFindOptionsRenameFromRewriteThreshold obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "rename-from-rewrite-threshold" + +{- | +Set the value of the “@rename-from-rewrite-threshold@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFindOptions [ #renameFromRewriteThreshold 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m () +setDiffFindOptionsRenameFromRewriteThreshold obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "rename-from-rewrite-threshold" val + +{- | +Construct a `GValueConstruct` with valid value for the “@rename-from-rewrite-threshold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFindOptionsRenameFromRewriteThreshold :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o) +constructDiffFindOptionsRenameFromRewriteThreshold val = B.Properties.constructObjectPropertyUInt32 "rename-from-rewrite-threshold" val + +#if ENABLE_OVERLOADING +data DiffFindOptionsRenameFromRewriteThresholdPropertyInfo +instance AttrInfo DiffFindOptionsRenameFromRewriteThresholdPropertyInfo where + type AttrAllowedOps DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = IsDiffFindOptions + type AttrGetType DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = Word32 + type AttrLabel DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = "rename-from-rewrite-threshold" + type AttrOrigin DiffFindOptionsRenameFromRewriteThresholdPropertyInfo = DiffFindOptions + attrGet _ = getDiffFindOptionsRenameFromRewriteThreshold + attrSet _ = setDiffFindOptionsRenameFromRewriteThreshold + attrConstruct _ = constructDiffFindOptionsRenameFromRewriteThreshold + attrClear _ = undefined +#endif + +-- VVV Prop "rename-limit" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@rename-limit@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFindOptions #renameLimit +@ +-} +getDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32 +getDiffFindOptionsRenameLimit obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "rename-limit" + +{- | +Set the value of the “@rename-limit@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFindOptions [ #renameLimit 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m () +setDiffFindOptionsRenameLimit obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "rename-limit" val + +{- | +Construct a `GValueConstruct` with valid value for the “@rename-limit@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFindOptionsRenameLimit :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o) +constructDiffFindOptionsRenameLimit val = B.Properties.constructObjectPropertyUInt32 "rename-limit" val + +#if ENABLE_OVERLOADING +data DiffFindOptionsRenameLimitPropertyInfo +instance AttrInfo DiffFindOptionsRenameLimitPropertyInfo where + type AttrAllowedOps DiffFindOptionsRenameLimitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint DiffFindOptionsRenameLimitPropertyInfo = IsDiffFindOptions + type AttrGetType DiffFindOptionsRenameLimitPropertyInfo = Word32 + type AttrLabel DiffFindOptionsRenameLimitPropertyInfo = "rename-limit" + type AttrOrigin DiffFindOptionsRenameLimitPropertyInfo = DiffFindOptions + attrGet _ = getDiffFindOptionsRenameLimit + attrSet _ = setDiffFindOptionsRenameLimit + attrConstruct _ = constructDiffFindOptionsRenameLimit + attrClear _ = undefined +#endif + +-- VVV Prop "rename-threshold" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@rename-threshold@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFindOptions #renameThreshold +@ +-} +getDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32 +getDiffFindOptionsRenameThreshold obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "rename-threshold" + +{- | +Set the value of the “@rename-threshold@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFindOptions [ #renameThreshold 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m () +setDiffFindOptionsRenameThreshold obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "rename-threshold" val + +{- | +Construct a `GValueConstruct` with valid value for the “@rename-threshold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFindOptionsRenameThreshold :: (IsDiffFindOptions o) => Word32 -> IO (GValueConstruct o) +constructDiffFindOptionsRenameThreshold val = B.Properties.constructObjectPropertyUInt32 "rename-threshold" val + +#if ENABLE_OVERLOADING +data DiffFindOptionsRenameThresholdPropertyInfo +instance AttrInfo DiffFindOptionsRenameThresholdPropertyInfo where + type AttrAllowedOps DiffFindOptionsRenameThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint DiffFindOptionsRenameThresholdPropertyInfo = IsDiffFindOptions + type AttrGetType DiffFindOptionsRenameThresholdPropertyInfo = Word32 + type AttrLabel DiffFindOptionsRenameThresholdPropertyInfo = "rename-threshold" + type AttrOrigin DiffFindOptionsRenameThresholdPropertyInfo = DiffFindOptions + attrGet _ = getDiffFindOptionsRenameThreshold + attrSet _ = setDiffFindOptionsRenameThreshold + attrConstruct _ = constructDiffFindOptionsRenameThreshold + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffFindOptions +type instance O.AttributeList DiffFindOptions = DiffFindOptionsAttributeList +type DiffFindOptionsAttributeList = ('[ '("copyThreshold", DiffFindOptionsCopyThresholdPropertyInfo), '("flags", DiffFindOptionsFlagsPropertyInfo), '("metric", DiffFindOptionsMetricPropertyInfo), '("renameFromRewriteThreshold", DiffFindOptionsRenameFromRewriteThresholdPropertyInfo), '("renameLimit", DiffFindOptionsRenameLimitPropertyInfo), '("renameThreshold", DiffFindOptionsRenameThresholdPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +diffFindOptionsCopyThreshold :: AttrLabelProxy "copyThreshold" +diffFindOptionsCopyThreshold = AttrLabelProxy + +diffFindOptionsFlags :: AttrLabelProxy "flags" +diffFindOptionsFlags = AttrLabelProxy + +diffFindOptionsMetric :: AttrLabelProxy "metric" +diffFindOptionsMetric = AttrLabelProxy + +diffFindOptionsRenameFromRewriteThreshold :: AttrLabelProxy "renameFromRewriteThreshold" +diffFindOptionsRenameFromRewriteThreshold = AttrLabelProxy + +diffFindOptionsRenameLimit :: AttrLabelProxy "renameLimit" +diffFindOptionsRenameLimit = AttrLabelProxy + +diffFindOptionsRenameThreshold :: AttrLabelProxy "renameThreshold" +diffFindOptionsRenameThreshold = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList DiffFindOptions = DiffFindOptionsSignalList +type DiffFindOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method DiffFindOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_find_options_new" ggit_diff_find_options_new :: + IO (Ptr DiffFindOptions) + +{- | +Creates a new 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. +-} +diffFindOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe DiffFindOptions) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions' or 'Nothing'. -} +diffFindOptionsNew = liftIO $ do + result <- ggit_diff_find_options_new + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject DiffFindOptions) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method DiffFindOptions::get_copy_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_find_options_get_copy_threshold" ggit_diff_find_options_get_copy_threshold :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + IO Word32 + +{- | +Get the find options copy threshold. +-} +diffFindOptionsGetCopyThreshold :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> m Word32 + {- ^ __Returns:__ the copy threshold. -} +diffFindOptionsGetCopyThreshold options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_find_options_get_copy_threshold options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffFindOptionsGetCopyThresholdMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetCopyThresholdMethodInfo a signature where + overloadedMethod _ = diffFindOptionsGetCopyThreshold + +#endif + +-- method DiffFindOptions::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFindFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_find_options_get_flags" ggit_diff_find_options_get_flags :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + IO CUInt + +{- | +Get the find options flags. +-} +diffFindOptionsGetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> m [Ggit.Flags.DiffFindFlags] + {- ^ __Returns:__ the find options flags. -} +diffFindOptionsGetFlags options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_find_options_get_flags options' + let result' = wordToGFlags result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data DiffFindOptionsGetFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.DiffFindFlags]), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetFlagsMethodInfo a signature where + overloadedMethod _ = diffFindOptionsGetFlags + +#endif + +-- method DiffFindOptions::get_metric +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_find_options_get_metric" ggit_diff_find_options_get_metric :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + IO (Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric) + +{- | +Get the find options metric. +-} +diffFindOptionsGetMetric :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric) + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric' or 'Nothing'. -} +diffFindOptionsGetMetric options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_find_options_get_metric options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.DiffSimilarityMetric.DiffSimilarityMetric) result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFindOptionsGetMetricMethodInfo +instance (signature ~ (m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetMetricMethodInfo a signature where + overloadedMethod _ = diffFindOptionsGetMetric + +#endif + +-- method DiffFindOptions::get_rename_from_rewrite_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_find_options_get_rename_from_rewrite_threshold" ggit_diff_find_options_get_rename_from_rewrite_threshold :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + IO Word32 + +{- | +Get the find options rename from rewrite threshold. +-} +diffFindOptionsGetRenameFromRewriteThreshold :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> m Word32 + {- ^ __Returns:__ the rename from rewrite threshold. -} +diffFindOptionsGetRenameFromRewriteThreshold options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_find_options_get_rename_from_rewrite_threshold options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo a signature where + overloadedMethod _ = diffFindOptionsGetRenameFromRewriteThreshold + +#endif + +-- method DiffFindOptions::get_rename_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", 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_find_options_get_rename_limit" ggit_diff_find_options_get_rename_limit :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + IO Word64 + +{- | +Get the find options rename limit. +-} +diffFindOptionsGetRenameLimit :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> m Word64 + {- ^ __Returns:__ the rename limit. -} +diffFindOptionsGetRenameLimit options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_find_options_get_rename_limit options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffFindOptionsGetRenameLimitMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetRenameLimitMethodInfo a signature where + overloadedMethod _ = diffFindOptionsGetRenameLimit + +#endif + +-- method DiffFindOptions::get_rename_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_find_options_get_rename_threshold" ggit_diff_find_options_get_rename_threshold :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + IO Word32 + +{- | +Get the find options rename threshold. +-} +diffFindOptionsGetRenameThreshold :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> m Word32 + {- ^ __Returns:__ the rename threshold. -} +diffFindOptionsGetRenameThreshold options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_find_options_get_rename_threshold options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffFindOptionsGetRenameThresholdMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsGetRenameThresholdMethodInfo a signature where + overloadedMethod _ = diffFindOptionsGetRenameThreshold + +#endif + +-- method DiffFindOptions::set_copy_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "threshold", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the threshold.", 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_find_options_set_copy_threshold" ggit_diff_find_options_set_copy_threshold :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + Word32 -> -- threshold : TBasicType TUInt + IO () + +{- | +Set the find options copy threshold. +-} +diffFindOptionsSetCopyThreshold :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> Word32 + {- ^ /@threshold@/: the threshold. -} + -> m () +diffFindOptionsSetCopyThreshold options threshold = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_find_options_set_copy_threshold options' threshold + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFindOptionsSetCopyThresholdMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetCopyThresholdMethodInfo a signature where + overloadedMethod _ = diffFindOptionsSetCopyThreshold + +#endif + +-- method DiffFindOptions::set_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindFlags.", 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_find_options_set_flags" ggit_diff_find_options_set_flags :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "DiffFindFlags"}) + IO () + +{- | +Set the find options flags. +-} +diffFindOptionsSetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> [Ggit.Flags.DiffFindFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.DiffFindFlags'. -} + -> m () +diffFindOptionsSetFlags options flags = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let flags' = gflagsToWord flags + ggit_diff_find_options_set_flags options' flags' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFindOptionsSetFlagsMethodInfo +instance (signature ~ ([Ggit.Flags.DiffFindFlags] -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetFlagsMethodInfo a signature where + overloadedMethod _ = diffFindOptionsSetFlags + +#endif + +-- method DiffFindOptions::set_metric +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metric", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetric.", 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_find_options_set_metric" ggit_diff_find_options_set_metric :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> -- metric : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}) + IO () + +{- | +Set the find options metric. +-} +diffFindOptionsSetMetric :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric + {- ^ /@metric@/: a 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric'. -} + -> m () +diffFindOptionsSetMetric options metric = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + metric' <- unsafeManagedPtrGetPtr metric + ggit_diff_find_options_set_metric options' metric' + touchManagedPtr options + touchManagedPtr metric + return () + +#if ENABLE_OVERLOADING +data DiffFindOptionsSetMetricMethodInfo +instance (signature ~ (Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetMetricMethodInfo a signature where + overloadedMethod _ = diffFindOptionsSetMetric + +#endif + +-- method DiffFindOptions::set_rename_from_rewrite_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "threshold", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the threshold.", 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_find_options_set_rename_from_rewrite_threshold" ggit_diff_find_options_set_rename_from_rewrite_threshold :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + Word32 -> -- threshold : TBasicType TUInt + IO () + +{- | +Set the find options rename from rewrite threshold. +-} +diffFindOptionsSetRenameFromRewriteThreshold :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> Word32 + {- ^ /@threshold@/: the threshold. -} + -> m () +diffFindOptionsSetRenameFromRewriteThreshold options threshold = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_find_options_set_rename_from_rewrite_threshold options' threshold + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo a signature where + overloadedMethod _ = diffFindOptionsSetRenameFromRewriteThreshold + +#endif + +-- method DiffFindOptions::set_rename_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the limit.", 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_find_options_set_rename_limit" ggit_diff_find_options_set_rename_limit :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + Word64 -> -- limit : TBasicType TUInt64 + IO () + +{- | +Set the find options rename limit. +-} +diffFindOptionsSetRenameLimit :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> Word64 + {- ^ /@limit@/: the limit. -} + -> m () +diffFindOptionsSetRenameLimit options limit = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_find_options_set_rename_limit options' limit + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFindOptionsSetRenameLimitMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetRenameLimitMethodInfo a signature where + overloadedMethod _ = diffFindOptionsSetRenameLimit + +#endif + +-- method DiffFindOptions::set_rename_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFindOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "threshold", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the threshold.", 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_find_options_set_rename_threshold" ggit_diff_find_options_set_rename_threshold :: + Ptr DiffFindOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFindOptions"}) + Word32 -> -- threshold : TBasicType TUInt + IO () + +{- | +Set the find options rename threshold. +-} +diffFindOptionsSetRenameThreshold :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFindOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFindOptions.DiffFindOptions'. -} + -> Word32 + {- ^ /@threshold@/: the threshold. -} + -> m () +diffFindOptionsSetRenameThreshold options threshold = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_find_options_set_rename_threshold options' threshold + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFindOptionsSetRenameThresholdMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsDiffFindOptions a) => O.MethodInfo DiffFindOptionsSetRenameThresholdMethodInfo a signature where + overloadedMethod _ = diffFindOptionsSetRenameThreshold + +#endif + + diff --git a/GI/Ggit/Objects/DiffFindOptions.hs-boot b/GI/Ggit/Objects/DiffFindOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/DiffFindOptions.hs-boot @@ -0,0 +1,83 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.DiffFindOptions 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 + +newtype DiffFindOptions = DiffFindOptions (ManagedPtr DiffFindOptions) +instance GObject DiffFindOptions where +class (GObject o, O.IsDescendantOf DiffFindOptions o) => IsDiffFindOptions o +instance (GObject o, O.IsDescendantOf DiffFindOptions o) => IsDiffFindOptions o +instance O.HasParentTypes DiffFindOptions +#if ENABLE_OVERLOADING +data DiffFindOptionsCopyThresholdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsFlagsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsMetricPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsRenameFromRewriteThresholdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsRenameLimitPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsRenameThresholdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsGetCopyThresholdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsGetMetricMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsGetRenameFromRewriteThresholdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsGetRenameLimitMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsGetRenameThresholdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsSetCopyThresholdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsSetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsSetMetricMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsSetRenameFromRewriteThresholdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsSetRenameLimitMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFindOptionsSetRenameThresholdMethodInfo +#endif diff --git a/GI/Ggit/Objects/DiffFormatEmailOptions.hs b/GI/Ggit/Objects/DiffFormatEmailOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/DiffFormatEmailOptions.hs @@ -0,0 +1,1320 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.DiffFormatEmailOptions + ( + +-- * Exported types + DiffFormatEmailOptions(..) , + IsDiffFormatEmailOptions , + toDiffFormatEmailOptions , + noDiffFormatEmailOptions , + + + -- * Methods +-- ** getAuthor #method:getAuthor# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsGetAuthorMethodInfo, +#endif + diffFormatEmailOptionsGetAuthor , + + +-- ** getBody #method:getBody# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsGetBodyMethodInfo , +#endif + diffFormatEmailOptionsGetBody , + + +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsGetFlagsMethodInfo, +#endif + diffFormatEmailOptionsGetFlags , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsGetIdMethodInfo , +#endif + diffFormatEmailOptionsGetId , + + +-- ** getPatchNumber #method:getPatchNumber# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsGetPatchNumberMethodInfo, +#endif + diffFormatEmailOptionsGetPatchNumber , + + +-- ** getSummary #method:getSummary# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsGetSummaryMethodInfo, +#endif + diffFormatEmailOptionsGetSummary , + + +-- ** getTotalPatches #method:getTotalPatches# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsGetTotalPatchesMethodInfo, +#endif + diffFormatEmailOptionsGetTotalPatches , + + +-- ** new #method:new# + + diffFormatEmailOptionsNew , + + +-- ** setAuthor #method:setAuthor# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSetAuthorMethodInfo, +#endif + diffFormatEmailOptionsSetAuthor , + + +-- ** setBody #method:setBody# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSetBodyMethodInfo , +#endif + diffFormatEmailOptionsSetBody , + + +-- ** setFlags #method:setFlags# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSetFlagsMethodInfo, +#endif + diffFormatEmailOptionsSetFlags , + + +-- ** setId #method:setId# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSetIdMethodInfo , +#endif + diffFormatEmailOptionsSetId , + + +-- ** setPatchNumber #method:setPatchNumber# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSetPatchNumberMethodInfo, +#endif + diffFormatEmailOptionsSetPatchNumber , + + +-- ** setSummary #method:setSummary# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSetSummaryMethodInfo, +#endif + diffFormatEmailOptionsSetSummary , + + +-- ** setTotalPatches #method:setTotalPatches# + +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSetTotalPatchesMethodInfo, +#endif + diffFormatEmailOptionsSetTotalPatches , + + + + + -- * Properties +-- ** author #attr:author# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsAuthorPropertyInfo, +#endif + clearDiffFormatEmailOptionsAuthor , + constructDiffFormatEmailOptionsAuthor , +#if ENABLE_OVERLOADING + diffFormatEmailOptionsAuthor , +#endif + getDiffFormatEmailOptionsAuthor , + setDiffFormatEmailOptionsAuthor , + + +-- ** body #attr:body# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsBodyPropertyInfo , +#endif + clearDiffFormatEmailOptionsBody , + constructDiffFormatEmailOptionsBody , +#if ENABLE_OVERLOADING + diffFormatEmailOptionsBody , +#endif + getDiffFormatEmailOptionsBody , + setDiffFormatEmailOptionsBody , + + +-- ** flags #attr:flags# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsFlagsPropertyInfo , +#endif + constructDiffFormatEmailOptionsFlags , +#if ENABLE_OVERLOADING + diffFormatEmailOptionsFlags , +#endif + getDiffFormatEmailOptionsFlags , + setDiffFormatEmailOptionsFlags , + + +-- ** id #attr:id# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsIdPropertyInfo , +#endif + clearDiffFormatEmailOptionsId , + constructDiffFormatEmailOptionsId , +#if ENABLE_OVERLOADING + diffFormatEmailOptionsId , +#endif + getDiffFormatEmailOptionsId , + setDiffFormatEmailOptionsId , + + +-- ** patchNumber #attr:patchNumber# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsPatchNumberPropertyInfo, +#endif + constructDiffFormatEmailOptionsPatchNumber, +#if ENABLE_OVERLOADING + diffFormatEmailOptionsPatchNumber , +#endif + getDiffFormatEmailOptionsPatchNumber , + setDiffFormatEmailOptionsPatchNumber , + + +-- ** summary #attr:summary# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsSummaryPropertyInfo, +#endif + clearDiffFormatEmailOptionsSummary , + constructDiffFormatEmailOptionsSummary , +#if ENABLE_OVERLOADING + diffFormatEmailOptionsSummary , +#endif + getDiffFormatEmailOptionsSummary , + setDiffFormatEmailOptionsSummary , + + +-- ** totalPatches #attr:totalPatches# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffFormatEmailOptionsTotalPatchesPropertyInfo, +#endif + constructDiffFormatEmailOptionsTotalPatches, +#if ENABLE_OVERLOADING + diffFormatEmailOptionsTotalPatches , +#endif + getDiffFormatEmailOptionsTotalPatches , + setDiffFormatEmailOptionsTotalPatches , + + + + + ) 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.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype DiffFormatEmailOptions = DiffFormatEmailOptions (ManagedPtr DiffFormatEmailOptions) +foreign import ccall "ggit_diff_format_email_options_get_type" + c_ggit_diff_format_email_options_get_type :: IO GType + +instance GObject DiffFormatEmailOptions where + gobjectType = c_ggit_diff_format_email_options_get_type + + +-- | Type class for types which can be safely cast to `DiffFormatEmailOptions`, for instance with `toDiffFormatEmailOptions`. +class (GObject o, O.IsDescendantOf DiffFormatEmailOptions o) => IsDiffFormatEmailOptions o +instance (GObject o, O.IsDescendantOf DiffFormatEmailOptions o) => IsDiffFormatEmailOptions o + +instance O.HasParentTypes DiffFormatEmailOptions +type instance O.ParentTypes DiffFormatEmailOptions = '[GObject.Object.Object] + +-- | Cast to `DiffFormatEmailOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDiffFormatEmailOptions :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m DiffFormatEmailOptions +toDiffFormatEmailOptions = liftIO . unsafeCastTo DiffFormatEmailOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffFormatEmailOptions`. +noDiffFormatEmailOptions :: Maybe DiffFormatEmailOptions +noDiffFormatEmailOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDiffFormatEmailOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffFormatEmailOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDiffFormatEmailOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDiffFormatEmailOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDiffFormatEmailOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDiffFormatEmailOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDiffFormatEmailOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDiffFormatEmailOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDiffFormatEmailOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDiffFormatEmailOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDiffFormatEmailOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDiffFormatEmailOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDiffFormatEmailOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDiffFormatEmailOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDiffFormatEmailOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDiffFormatEmailOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDiffFormatEmailOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDiffFormatEmailOptionsMethod "getAuthor" o = DiffFormatEmailOptionsGetAuthorMethodInfo + ResolveDiffFormatEmailOptionsMethod "getBody" o = DiffFormatEmailOptionsGetBodyMethodInfo + ResolveDiffFormatEmailOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDiffFormatEmailOptionsMethod "getFlags" o = DiffFormatEmailOptionsGetFlagsMethodInfo + ResolveDiffFormatEmailOptionsMethod "getId" o = DiffFormatEmailOptionsGetIdMethodInfo + ResolveDiffFormatEmailOptionsMethod "getPatchNumber" o = DiffFormatEmailOptionsGetPatchNumberMethodInfo + ResolveDiffFormatEmailOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDiffFormatEmailOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDiffFormatEmailOptionsMethod "getSummary" o = DiffFormatEmailOptionsGetSummaryMethodInfo + ResolveDiffFormatEmailOptionsMethod "getTotalPatches" o = DiffFormatEmailOptionsGetTotalPatchesMethodInfo + ResolveDiffFormatEmailOptionsMethod "setAuthor" o = DiffFormatEmailOptionsSetAuthorMethodInfo + ResolveDiffFormatEmailOptionsMethod "setBody" o = DiffFormatEmailOptionsSetBodyMethodInfo + ResolveDiffFormatEmailOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDiffFormatEmailOptionsMethod "setFlags" o = DiffFormatEmailOptionsSetFlagsMethodInfo + ResolveDiffFormatEmailOptionsMethod "setId" o = DiffFormatEmailOptionsSetIdMethodInfo + ResolveDiffFormatEmailOptionsMethod "setPatchNumber" o = DiffFormatEmailOptionsSetPatchNumberMethodInfo + ResolveDiffFormatEmailOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDiffFormatEmailOptionsMethod "setSummary" o = DiffFormatEmailOptionsSetSummaryMethodInfo + ResolveDiffFormatEmailOptionsMethod "setTotalPatches" o = DiffFormatEmailOptionsSetTotalPatchesMethodInfo + ResolveDiffFormatEmailOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffFormatEmailOptionsMethod t DiffFormatEmailOptions, O.MethodInfo info DiffFormatEmailOptions p) => OL.IsLabel t (DiffFormatEmailOptions -> 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 + +-- VVV Prop "author" + -- Type: TInterface (Name {namespace = "Ggit", name = "Signature"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@author@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFormatEmailOptions #author +@ +-} +getDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe Ggit.Signature.Signature) +getDiffFormatEmailOptionsAuthor obj = liftIO $ B.Properties.getObjectPropertyObject obj "author" Ggit.Signature.Signature + +{- | +Set the value of the “@author@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #author 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o, Ggit.Signature.IsSignature a) => o -> a -> m () +setDiffFormatEmailOptionsAuthor obj val = liftIO $ B.Properties.setObjectPropertyObject obj "author" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@author@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFormatEmailOptionsAuthor :: (IsDiffFormatEmailOptions o, Ggit.Signature.IsSignature a) => a -> IO (GValueConstruct o) +constructDiffFormatEmailOptionsAuthor val = B.Properties.constructObjectPropertyObject "author" (Just val) + +{- | +Set the value of the “@author@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #author +@ +-} +clearDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m () +clearDiffFormatEmailOptionsAuthor obj = liftIO $ B.Properties.setObjectPropertyObject obj "author" (Nothing :: Maybe Ggit.Signature.Signature) + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsAuthorPropertyInfo +instance AttrInfo DiffFormatEmailOptionsAuthorPropertyInfo where + type AttrAllowedOps DiffFormatEmailOptionsAuthorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffFormatEmailOptionsAuthorPropertyInfo = Ggit.Signature.IsSignature + type AttrBaseTypeConstraint DiffFormatEmailOptionsAuthorPropertyInfo = IsDiffFormatEmailOptions + type AttrGetType DiffFormatEmailOptionsAuthorPropertyInfo = (Maybe Ggit.Signature.Signature) + type AttrLabel DiffFormatEmailOptionsAuthorPropertyInfo = "author" + type AttrOrigin DiffFormatEmailOptionsAuthorPropertyInfo = DiffFormatEmailOptions + attrGet _ = getDiffFormatEmailOptionsAuthor + attrSet _ = setDiffFormatEmailOptionsAuthor + attrConstruct _ = constructDiffFormatEmailOptionsAuthor + attrClear _ = clearDiffFormatEmailOptionsAuthor +#endif + +-- VVV Prop "body" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@body@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFormatEmailOptions #body +@ +-} +getDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe T.Text) +getDiffFormatEmailOptionsBody obj = liftIO $ B.Properties.getObjectPropertyString obj "body" + +{- | +Set the value of the “@body@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #body 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> T.Text -> m () +setDiffFormatEmailOptionsBody obj val = liftIO $ B.Properties.setObjectPropertyString obj "body" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@body@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFormatEmailOptionsBody :: (IsDiffFormatEmailOptions o) => T.Text -> IO (GValueConstruct o) +constructDiffFormatEmailOptionsBody val = B.Properties.constructObjectPropertyString "body" (Just val) + +{- | +Set the value of the “@body@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #body +@ +-} +clearDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m () +clearDiffFormatEmailOptionsBody obj = liftIO $ B.Properties.setObjectPropertyString obj "body" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsBodyPropertyInfo +instance AttrInfo DiffFormatEmailOptionsBodyPropertyInfo where + type AttrAllowedOps DiffFormatEmailOptionsBodyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffFormatEmailOptionsBodyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DiffFormatEmailOptionsBodyPropertyInfo = IsDiffFormatEmailOptions + type AttrGetType DiffFormatEmailOptionsBodyPropertyInfo = (Maybe T.Text) + type AttrLabel DiffFormatEmailOptionsBodyPropertyInfo = "body" + type AttrOrigin DiffFormatEmailOptionsBodyPropertyInfo = DiffFormatEmailOptions + attrGet _ = getDiffFormatEmailOptionsBody + attrSet _ = setDiffFormatEmailOptionsBody + attrConstruct _ = constructDiffFormatEmailOptionsBody + attrClear _ = clearDiffFormatEmailOptionsBody +#endif + +-- VVV Prop "flags" + -- Type: TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailFlags"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFormatEmailOptions #flags +@ +-} +getDiffFormatEmailOptionsFlags :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m [Ggit.Flags.DiffFormatEmailFlags] +getDiffFormatEmailOptionsFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags" + +{- | +Set the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFormatEmailOptionsFlags :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> [Ggit.Flags.DiffFormatEmailFlags] -> m () +setDiffFormatEmailOptionsFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val + +{- | +Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFormatEmailOptionsFlags :: (IsDiffFormatEmailOptions o) => [Ggit.Flags.DiffFormatEmailFlags] -> IO (GValueConstruct o) +constructDiffFormatEmailOptionsFlags val = B.Properties.constructObjectPropertyFlags "flags" val + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsFlagsPropertyInfo +instance AttrInfo DiffFormatEmailOptionsFlagsPropertyInfo where + type AttrAllowedOps DiffFormatEmailOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFormatEmailOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffFormatEmailFlags] + type AttrBaseTypeConstraint DiffFormatEmailOptionsFlagsPropertyInfo = IsDiffFormatEmailOptions + type AttrGetType DiffFormatEmailOptionsFlagsPropertyInfo = [Ggit.Flags.DiffFormatEmailFlags] + type AttrLabel DiffFormatEmailOptionsFlagsPropertyInfo = "flags" + type AttrOrigin DiffFormatEmailOptionsFlagsPropertyInfo = DiffFormatEmailOptions + attrGet _ = getDiffFormatEmailOptionsFlags + attrSet _ = setDiffFormatEmailOptionsFlags + attrConstruct _ = constructDiffFormatEmailOptionsFlags + attrClear _ = undefined +#endif + +-- VVV Prop "id" + -- Type: TInterface (Name {namespace = "Ggit", name = "OId"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFormatEmailOptions #id +@ +-} +getDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe Ggit.OId.OId) +getDiffFormatEmailOptionsId obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "id" Ggit.OId.OId + +{- | +Set the value of the “@id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #id 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Ggit.OId.OId -> m () +setDiffFormatEmailOptionsId obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "id" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFormatEmailOptionsId :: (IsDiffFormatEmailOptions o) => Ggit.OId.OId -> IO (GValueConstruct o) +constructDiffFormatEmailOptionsId val = B.Properties.constructObjectPropertyBoxed "id" (Just val) + +{- | +Set the value of the “@id@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #id +@ +-} +clearDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m () +clearDiffFormatEmailOptionsId obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "id" (Nothing :: Maybe Ggit.OId.OId) + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsIdPropertyInfo +instance AttrInfo DiffFormatEmailOptionsIdPropertyInfo where + type AttrAllowedOps DiffFormatEmailOptionsIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffFormatEmailOptionsIdPropertyInfo = (~) Ggit.OId.OId + type AttrBaseTypeConstraint DiffFormatEmailOptionsIdPropertyInfo = IsDiffFormatEmailOptions + type AttrGetType DiffFormatEmailOptionsIdPropertyInfo = (Maybe Ggit.OId.OId) + type AttrLabel DiffFormatEmailOptionsIdPropertyInfo = "id" + type AttrOrigin DiffFormatEmailOptionsIdPropertyInfo = DiffFormatEmailOptions + attrGet _ = getDiffFormatEmailOptionsId + attrSet _ = setDiffFormatEmailOptionsId + attrConstruct _ = constructDiffFormatEmailOptionsId + attrClear _ = clearDiffFormatEmailOptionsId +#endif + +-- VVV Prop "patch-number" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@patch-number@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFormatEmailOptions #patchNumber +@ +-} +getDiffFormatEmailOptionsPatchNumber :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m Word64 +getDiffFormatEmailOptionsPatchNumber obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "patch-number" + +{- | +Set the value of the “@patch-number@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #patchNumber 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFormatEmailOptionsPatchNumber :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Word64 -> m () +setDiffFormatEmailOptionsPatchNumber obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "patch-number" val + +{- | +Construct a `GValueConstruct` with valid value for the “@patch-number@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFormatEmailOptionsPatchNumber :: (IsDiffFormatEmailOptions o) => Word64 -> IO (GValueConstruct o) +constructDiffFormatEmailOptionsPatchNumber val = B.Properties.constructObjectPropertyUInt64 "patch-number" val + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsPatchNumberPropertyInfo +instance AttrInfo DiffFormatEmailOptionsPatchNumberPropertyInfo where + type AttrAllowedOps DiffFormatEmailOptionsPatchNumberPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFormatEmailOptionsPatchNumberPropertyInfo = (~) Word64 + type AttrBaseTypeConstraint DiffFormatEmailOptionsPatchNumberPropertyInfo = IsDiffFormatEmailOptions + type AttrGetType DiffFormatEmailOptionsPatchNumberPropertyInfo = Word64 + type AttrLabel DiffFormatEmailOptionsPatchNumberPropertyInfo = "patch-number" + type AttrOrigin DiffFormatEmailOptionsPatchNumberPropertyInfo = DiffFormatEmailOptions + attrGet _ = getDiffFormatEmailOptionsPatchNumber + attrSet _ = setDiffFormatEmailOptionsPatchNumber + attrConstruct _ = constructDiffFormatEmailOptionsPatchNumber + attrClear _ = undefined +#endif + +-- VVV Prop "summary" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@summary@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFormatEmailOptions #summary +@ +-} +getDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe T.Text) +getDiffFormatEmailOptionsSummary obj = liftIO $ B.Properties.getObjectPropertyString obj "summary" + +{- | +Set the value of the “@summary@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #summary 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> T.Text -> m () +setDiffFormatEmailOptionsSummary obj val = liftIO $ B.Properties.setObjectPropertyString obj "summary" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@summary@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFormatEmailOptionsSummary :: (IsDiffFormatEmailOptions o) => T.Text -> IO (GValueConstruct o) +constructDiffFormatEmailOptionsSummary val = B.Properties.constructObjectPropertyString "summary" (Just val) + +{- | +Set the value of the “@summary@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #summary +@ +-} +clearDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m () +clearDiffFormatEmailOptionsSummary obj = liftIO $ B.Properties.setObjectPropertyString obj "summary" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSummaryPropertyInfo +instance AttrInfo DiffFormatEmailOptionsSummaryPropertyInfo where + type AttrAllowedOps DiffFormatEmailOptionsSummaryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffFormatEmailOptionsSummaryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DiffFormatEmailOptionsSummaryPropertyInfo = IsDiffFormatEmailOptions + type AttrGetType DiffFormatEmailOptionsSummaryPropertyInfo = (Maybe T.Text) + type AttrLabel DiffFormatEmailOptionsSummaryPropertyInfo = "summary" + type AttrOrigin DiffFormatEmailOptionsSummaryPropertyInfo = DiffFormatEmailOptions + attrGet _ = getDiffFormatEmailOptionsSummary + attrSet _ = setDiffFormatEmailOptionsSummary + attrConstruct _ = constructDiffFormatEmailOptionsSummary + attrClear _ = clearDiffFormatEmailOptionsSummary +#endif + +-- VVV Prop "total-patches" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@total-patches@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffFormatEmailOptions #totalPatches +@ +-} +getDiffFormatEmailOptionsTotalPatches :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m Word64 +getDiffFormatEmailOptionsTotalPatches obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "total-patches" + +{- | +Set the value of the “@total-patches@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffFormatEmailOptions [ #totalPatches 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffFormatEmailOptionsTotalPatches :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Word64 -> m () +setDiffFormatEmailOptionsTotalPatches obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "total-patches" val + +{- | +Construct a `GValueConstruct` with valid value for the “@total-patches@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffFormatEmailOptionsTotalPatches :: (IsDiffFormatEmailOptions o) => Word64 -> IO (GValueConstruct o) +constructDiffFormatEmailOptionsTotalPatches val = B.Properties.constructObjectPropertyUInt64 "total-patches" val + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsTotalPatchesPropertyInfo +instance AttrInfo DiffFormatEmailOptionsTotalPatchesPropertyInfo where + type AttrAllowedOps DiffFormatEmailOptionsTotalPatchesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffFormatEmailOptionsTotalPatchesPropertyInfo = (~) Word64 + type AttrBaseTypeConstraint DiffFormatEmailOptionsTotalPatchesPropertyInfo = IsDiffFormatEmailOptions + type AttrGetType DiffFormatEmailOptionsTotalPatchesPropertyInfo = Word64 + type AttrLabel DiffFormatEmailOptionsTotalPatchesPropertyInfo = "total-patches" + type AttrOrigin DiffFormatEmailOptionsTotalPatchesPropertyInfo = DiffFormatEmailOptions + attrGet _ = getDiffFormatEmailOptionsTotalPatches + attrSet _ = setDiffFormatEmailOptionsTotalPatches + attrConstruct _ = constructDiffFormatEmailOptionsTotalPatches + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffFormatEmailOptions +type instance O.AttributeList DiffFormatEmailOptions = DiffFormatEmailOptionsAttributeList +type DiffFormatEmailOptionsAttributeList = ('[ '("author", DiffFormatEmailOptionsAuthorPropertyInfo), '("body", DiffFormatEmailOptionsBodyPropertyInfo), '("flags", DiffFormatEmailOptionsFlagsPropertyInfo), '("id", DiffFormatEmailOptionsIdPropertyInfo), '("patchNumber", DiffFormatEmailOptionsPatchNumberPropertyInfo), '("summary", DiffFormatEmailOptionsSummaryPropertyInfo), '("totalPatches", DiffFormatEmailOptionsTotalPatchesPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +diffFormatEmailOptionsAuthor :: AttrLabelProxy "author" +diffFormatEmailOptionsAuthor = AttrLabelProxy + +diffFormatEmailOptionsBody :: AttrLabelProxy "body" +diffFormatEmailOptionsBody = AttrLabelProxy + +diffFormatEmailOptionsFlags :: AttrLabelProxy "flags" +diffFormatEmailOptionsFlags = AttrLabelProxy + +diffFormatEmailOptionsId :: AttrLabelProxy "id" +diffFormatEmailOptionsId = AttrLabelProxy + +diffFormatEmailOptionsPatchNumber :: AttrLabelProxy "patchNumber" +diffFormatEmailOptionsPatchNumber = AttrLabelProxy + +diffFormatEmailOptionsSummary :: AttrLabelProxy "summary" +diffFormatEmailOptionsSummary = AttrLabelProxy + +diffFormatEmailOptionsTotalPatches :: AttrLabelProxy "totalPatches" +diffFormatEmailOptionsTotalPatches = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList DiffFormatEmailOptions = DiffFormatEmailOptionsSignalList +type DiffFormatEmailOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method DiffFormatEmailOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_format_email_options_new" ggit_diff_format_email_options_new :: + IO (Ptr DiffFormatEmailOptions) + +{- | +Create a new checkout options object. +-} +diffFormatEmailOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe DiffFormatEmailOptions) + {- ^ __Returns:__ a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions' or 'Nothing'. -} +diffFormatEmailOptionsNew = liftIO $ do + result <- ggit_diff_format_email_options_new + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject DiffFormatEmailOptions) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method DiffFormatEmailOptions::get_author +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_format_email_options_get_author" ggit_diff_format_email_options_get_author :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + IO (Ptr Ggit.Signature.Signature) + +{- | +Get the author. +-} +diffFormatEmailOptionsGetAuthor :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m (Maybe Ggit.Signature.Signature) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Signature.Signature' or 'Nothing'. -} +diffFormatEmailOptionsGetAuthor options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_format_email_options_get_author options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.Signature.Signature) result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetAuthorMethodInfo +instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetAuthorMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsGetAuthor + +#endif + +-- method DiffFormatEmailOptions::get_body +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_format_email_options_get_body" ggit_diff_format_email_options_get_body :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + IO CString + +{- | +Get the body. +-} +diffFormatEmailOptionsGetBody :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the body. -} +diffFormatEmailOptionsGetBody options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_format_email_options_get_body options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetBodyMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetBodyMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsGetBody + +#endif + +-- method DiffFormatEmailOptions::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_format_email_options_get_flags" ggit_diff_format_email_options_get_flags :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + IO CUInt + +{- | +Get the flags. +-} +diffFormatEmailOptionsGetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m [Ggit.Flags.DiffFormatEmailFlags] + {- ^ __Returns:__ a 'GI.Ggit.Flags.DiffFormatEmailFlags'. -} +diffFormatEmailOptionsGetFlags options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_format_email_options_get_flags options' + let result' = wordToGFlags result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.DiffFormatEmailFlags]), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetFlagsMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsGetFlags + +#endif + +-- method DiffFormatEmailOptions::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_format_email_options_get_id" ggit_diff_format_email_options_get_id :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the object id. +-} +diffFormatEmailOptionsGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +diffFormatEmailOptionsGetId options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_format_email_options_get_id options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetIdMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsGetId + +#endif + +-- method DiffFormatEmailOptions::get_patch_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", 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_format_email_options_get_patch_number" ggit_diff_format_email_options_get_patch_number :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + IO Word64 + +{- | +Get the patch number. +-} +diffFormatEmailOptionsGetPatchNumber :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m Word64 + {- ^ __Returns:__ the patch number. -} +diffFormatEmailOptionsGetPatchNumber options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_format_email_options_get_patch_number options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetPatchNumberMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetPatchNumberMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsGetPatchNumber + +#endif + +-- method DiffFormatEmailOptions::get_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_format_email_options_get_summary" ggit_diff_format_email_options_get_summary :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + IO CString + +{- | +Get the summary. +-} +diffFormatEmailOptionsGetSummary :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the summary. -} +diffFormatEmailOptionsGetSummary options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_format_email_options_get_summary options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetSummaryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetSummaryMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsGetSummary + +#endif + +-- method DiffFormatEmailOptions::get_total_patches +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", 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_format_email_options_get_total_patches" ggit_diff_format_email_options_get_total_patches :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + IO Word64 + +{- | +Get the total number of patches. +-} +diffFormatEmailOptionsGetTotalPatches :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> m Word64 + {- ^ __Returns:__ the total number of patches. -} +diffFormatEmailOptionsGetTotalPatches options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_format_email_options_get_total_patches options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetTotalPatchesMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsGetTotalPatchesMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsGetTotalPatches + +#endif + +-- method DiffFormatEmailOptions::set_author +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", 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_format_email_options_set_author" ggit_diff_format_email_options_set_author :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + Ptr Ggit.Signature.Signature -> -- author : TInterface (Name {namespace = "Ggit", name = "Signature"}) + IO () + +{- | +Set the author. +-} +diffFormatEmailOptionsSetAuthor :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a, Ggit.Signature.IsSignature b) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> Maybe (b) + {- ^ /@author@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> m () +diffFormatEmailOptionsSetAuthor options author = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeAuthor <- case author of + Nothing -> return nullPtr + Just jAuthor -> do + jAuthor' <- unsafeManagedPtrCastPtr jAuthor + return jAuthor' + ggit_diff_format_email_options_set_author options' maybeAuthor + touchManagedPtr options + whenJust author touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetAuthorMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDiffFormatEmailOptions a, Ggit.Signature.IsSignature b) => O.MethodInfo DiffFormatEmailOptionsSetAuthorMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsSetAuthor + +#endif + +-- method DiffFormatEmailOptions::set_body +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "body", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the body.", 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_format_email_options_set_body" ggit_diff_format_email_options_set_body :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + CString -> -- body : TBasicType TUTF8 + IO () + +{- | +Set the body. +-} +diffFormatEmailOptionsSetBody :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> Maybe (T.Text) + {- ^ /@body@/: the body. -} + -> m () +diffFormatEmailOptionsSetBody options body = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeBody <- case body of + Nothing -> return nullPtr + Just jBody -> do + jBody' <- textToCString jBody + return jBody' + ggit_diff_format_email_options_set_body options' maybeBody + touchManagedPtr options + freeMem maybeBody + return () + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetBodyMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetBodyMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsSetBody + +#endif + +-- method DiffFormatEmailOptions::set_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailFlags.", 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_format_email_options_set_flags" ggit_diff_format_email_options_set_flags :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailFlags"}) + IO () + +{- | +Set the flags. +-} +diffFormatEmailOptionsSetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> [Ggit.Flags.DiffFormatEmailFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.DiffFormatEmailFlags'. -} + -> m () +diffFormatEmailOptionsSetFlags options flags = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let flags' = gflagsToWord flags + ggit_diff_format_email_options_set_flags options' flags' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetFlagsMethodInfo +instance (signature ~ ([Ggit.Flags.DiffFormatEmailFlags] -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetFlagsMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsSetFlags + +#endif + +-- method DiffFormatEmailOptions::set_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitOId.", 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_format_email_options_set_id" ggit_diff_format_email_options_set_id :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + Ptr Ggit.OId.OId -> -- id : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO () + +{- | +Set the object id. +-} +diffFormatEmailOptionsSetId :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> Maybe (Ggit.OId.OId) + {- ^ /@id@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m () +diffFormatEmailOptionsSetId options id = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeId <- case id of + Nothing -> return nullPtr + Just jId -> do + jId' <- unsafeManagedPtrGetPtr jId + return jId' + ggit_diff_format_email_options_set_id options' maybeId + touchManagedPtr options + whenJust id touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetIdMethodInfo +instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetIdMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsSetId + +#endif + +-- method DiffFormatEmailOptions::set_patch_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "number", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the patch number.", 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_format_email_options_set_patch_number" ggit_diff_format_email_options_set_patch_number :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + Word64 -> -- number : TBasicType TUInt64 + IO () + +{- | +Set the patch number. +-} +diffFormatEmailOptionsSetPatchNumber :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> Word64 + {- ^ /@number@/: the patch number. -} + -> m () +diffFormatEmailOptionsSetPatchNumber options number = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_format_email_options_set_patch_number options' number + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetPatchNumberMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetPatchNumberMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsSetPatchNumber + +#endif + +-- method DiffFormatEmailOptions::set_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "summary", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the summary.", 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_format_email_options_set_summary" ggit_diff_format_email_options_set_summary :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + CString -> -- summary : TBasicType TUTF8 + IO () + +{- | +Set the summary. +-} +diffFormatEmailOptionsSetSummary :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> Maybe (T.Text) + {- ^ /@summary@/: the summary. -} + -> m () +diffFormatEmailOptionsSetSummary options summary = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeSummary <- case summary of + Nothing -> return nullPtr + Just jSummary -> do + jSummary' <- textToCString jSummary + return jSummary' + ggit_diff_format_email_options_set_summary options' maybeSummary + touchManagedPtr options + freeMem maybeSummary + return () + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetSummaryMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetSummaryMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsSetSummary + +#endif + +-- method DiffFormatEmailOptions::set_total_patches +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFormatEmailOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "patches", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the total number of patches.", 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_format_email_options_set_total_patches" ggit_diff_format_email_options_set_total_patches :: + Ptr DiffFormatEmailOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffFormatEmailOptions"}) + Word64 -> -- patches : TBasicType TUInt64 + IO () + +{- | +Set the total number of patches. +-} +diffFormatEmailOptionsSetTotalPatches :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions'. -} + -> Word64 + {- ^ /@patches@/: the total number of patches. -} + -> m () +diffFormatEmailOptionsSetTotalPatches options patches = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_format_email_options_set_total_patches options' patches + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetTotalPatchesMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiffFormatEmailOptions a) => O.MethodInfo DiffFormatEmailOptionsSetTotalPatchesMethodInfo a signature where + overloadedMethod _ = diffFormatEmailOptionsSetTotalPatches + +#endif + + diff --git a/GI/Ggit/Objects/DiffFormatEmailOptions.hs-boot b/GI/Ggit/Objects/DiffFormatEmailOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/DiffFormatEmailOptions.hs-boot @@ -0,0 +1,92 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.DiffFormatEmailOptions 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 + +newtype DiffFormatEmailOptions = DiffFormatEmailOptions (ManagedPtr DiffFormatEmailOptions) +instance GObject DiffFormatEmailOptions where +class (GObject o, O.IsDescendantOf DiffFormatEmailOptions o) => IsDiffFormatEmailOptions o +instance (GObject o, O.IsDescendantOf DiffFormatEmailOptions o) => IsDiffFormatEmailOptions o +instance O.HasParentTypes DiffFormatEmailOptions +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsAuthorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsBodyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsFlagsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsIdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsPatchNumberPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSummaryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsTotalPatchesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetAuthorMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetBodyMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetPatchNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetSummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsGetTotalPatchesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetAuthorMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetBodyMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetPatchNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetSummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFormatEmailOptionsSetTotalPatchesMethodInfo +#endif diff --git a/GI/Ggit/Objects/DiffOptions.hs b/GI/Ggit/Objects/DiffOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/DiffOptions.hs @@ -0,0 +1,1114 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when creating a 'GI.Ggit.Objects.Diff.Diff'. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.DiffOptions + ( + +-- * Exported types + DiffOptions(..) , + IsDiffOptions , + toDiffOptions , + noDiffOptions , + + + -- * Methods +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + DiffOptionsGetFlagsMethodInfo , +#endif + diffOptionsGetFlags , + + +-- ** getNContextLines #method:getNContextLines# + +#if ENABLE_OVERLOADING + DiffOptionsGetNContextLinesMethodInfo , +#endif + diffOptionsGetNContextLines , + + +-- ** getNInterhunkLines #method:getNInterhunkLines# + +#if ENABLE_OVERLOADING + DiffOptionsGetNInterhunkLinesMethodInfo , +#endif + diffOptionsGetNInterhunkLines , + + +-- ** getNewPrefix #method:getNewPrefix# + +#if ENABLE_OVERLOADING + DiffOptionsGetNewPrefixMethodInfo , +#endif + diffOptionsGetNewPrefix , + + +-- ** getOldPrefix #method:getOldPrefix# + +#if ENABLE_OVERLOADING + DiffOptionsGetOldPrefixMethodInfo , +#endif + diffOptionsGetOldPrefix , + + +-- ** getPathspec #method:getPathspec# + +#if ENABLE_OVERLOADING + DiffOptionsGetPathspecMethodInfo , +#endif + diffOptionsGetPathspec , + + +-- ** new #method:new# + + diffOptionsNew , + + +-- ** setFlags #method:setFlags# + +#if ENABLE_OVERLOADING + DiffOptionsSetFlagsMethodInfo , +#endif + diffOptionsSetFlags , + + +-- ** setNContextLines #method:setNContextLines# + +#if ENABLE_OVERLOADING + DiffOptionsSetNContextLinesMethodInfo , +#endif + diffOptionsSetNContextLines , + + +-- ** setNInterhunkLines #method:setNInterhunkLines# + +#if ENABLE_OVERLOADING + DiffOptionsSetNInterhunkLinesMethodInfo , +#endif + diffOptionsSetNInterhunkLines , + + +-- ** setNewPrefix #method:setNewPrefix# + +#if ENABLE_OVERLOADING + DiffOptionsSetNewPrefixMethodInfo , +#endif + diffOptionsSetNewPrefix , + + +-- ** setOldPrefix #method:setOldPrefix# + +#if ENABLE_OVERLOADING + DiffOptionsSetOldPrefixMethodInfo , +#endif + diffOptionsSetOldPrefix , + + +-- ** setPathspec #method:setPathspec# + +#if ENABLE_OVERLOADING + DiffOptionsSetPathspecMethodInfo , +#endif + diffOptionsSetPathspec , + + + + + -- * Properties +-- ** flags #attr:flags# +{- | The diff option flags. +-} +#if ENABLE_OVERLOADING + DiffOptionsFlagsPropertyInfo , +#endif + constructDiffOptionsFlags , +#if ENABLE_OVERLOADING + diffOptionsFlags , +#endif + getDiffOptionsFlags , + setDiffOptionsFlags , + + +-- ** nContextLines #attr:nContextLines# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffOptionsNContextLinesPropertyInfo , +#endif + constructDiffOptionsNContextLines , +#if ENABLE_OVERLOADING + diffOptionsNContextLines , +#endif + getDiffOptionsNContextLines , + setDiffOptionsNContextLines , + + +-- ** nInterhunkLines #attr:nInterhunkLines# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffOptionsNInterhunkLinesPropertyInfo , +#endif + constructDiffOptionsNInterhunkLines , +#if ENABLE_OVERLOADING + diffOptionsNInterhunkLines , +#endif + getDiffOptionsNInterhunkLines , + setDiffOptionsNInterhunkLines , + + +-- ** newPrefix #attr:newPrefix# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffOptionsNewPrefixPropertyInfo , +#endif + constructDiffOptionsNewPrefix , +#if ENABLE_OVERLOADING + diffOptionsNewPrefix , +#endif + getDiffOptionsNewPrefix , + setDiffOptionsNewPrefix , + + +-- ** oldPrefix #attr:oldPrefix# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffOptionsOldPrefixPropertyInfo , +#endif + constructDiffOptionsOldPrefix , +#if ENABLE_OVERLOADING + diffOptionsOldPrefix , +#endif + getDiffOptionsOldPrefix , + setDiffOptionsOldPrefix , + + +-- ** pathspec #attr:pathspec# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DiffOptionsPathspecPropertyInfo , +#endif + clearDiffOptionsPathspec , + constructDiffOptionsPathspec , +#if ENABLE_OVERLOADING + diffOptionsPathspec , +#endif + getDiffOptionsPathspec , + setDiffOptionsPathspec , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype DiffOptions = DiffOptions (ManagedPtr DiffOptions) +foreign import ccall "ggit_diff_options_get_type" + c_ggit_diff_options_get_type :: IO GType + +instance GObject DiffOptions where + gobjectType = c_ggit_diff_options_get_type + + +-- | Type class for types which can be safely cast to `DiffOptions`, for instance with `toDiffOptions`. +class (GObject o, O.IsDescendantOf DiffOptions o) => IsDiffOptions o +instance (GObject o, O.IsDescendantOf DiffOptions o) => IsDiffOptions o + +instance O.HasParentTypes DiffOptions +type instance O.ParentTypes DiffOptions = '[GObject.Object.Object] + +-- | Cast to `DiffOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDiffOptions :: (MonadIO m, IsDiffOptions o) => o -> m DiffOptions +toDiffOptions = liftIO . unsafeCastTo DiffOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffOptions`. +noDiffOptions :: Maybe DiffOptions +noDiffOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDiffOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDiffOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDiffOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDiffOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDiffOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDiffOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDiffOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDiffOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDiffOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDiffOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDiffOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDiffOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDiffOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDiffOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDiffOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDiffOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDiffOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDiffOptionsMethod "getFlags" o = DiffOptionsGetFlagsMethodInfo + ResolveDiffOptionsMethod "getNContextLines" o = DiffOptionsGetNContextLinesMethodInfo + ResolveDiffOptionsMethod "getNInterhunkLines" o = DiffOptionsGetNInterhunkLinesMethodInfo + ResolveDiffOptionsMethod "getNewPrefix" o = DiffOptionsGetNewPrefixMethodInfo + ResolveDiffOptionsMethod "getOldPrefix" o = DiffOptionsGetOldPrefixMethodInfo + ResolveDiffOptionsMethod "getPathspec" o = DiffOptionsGetPathspecMethodInfo + ResolveDiffOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDiffOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDiffOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDiffOptionsMethod "setFlags" o = DiffOptionsSetFlagsMethodInfo + ResolveDiffOptionsMethod "setNContextLines" o = DiffOptionsSetNContextLinesMethodInfo + ResolveDiffOptionsMethod "setNInterhunkLines" o = DiffOptionsSetNInterhunkLinesMethodInfo + ResolveDiffOptionsMethod "setNewPrefix" o = DiffOptionsSetNewPrefixMethodInfo + ResolveDiffOptionsMethod "setOldPrefix" o = DiffOptionsSetOldPrefixMethodInfo + ResolveDiffOptionsMethod "setPathspec" o = DiffOptionsSetPathspecMethodInfo + ResolveDiffOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDiffOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffOptionsMethod t DiffOptions, O.MethodInfo info DiffOptions p) => OL.IsLabel t (DiffOptions -> 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 + +-- VVV Prop "flags" + -- Type: TInterface (Name {namespace = "Ggit", name = "DiffOption"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffOptions #flags +@ +-} +getDiffOptionsFlags :: (MonadIO m, IsDiffOptions o) => o -> m [Ggit.Flags.DiffOption] +getDiffOptionsFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags" + +{- | +Set the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffOptions [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffOptionsFlags :: (MonadIO m, IsDiffOptions o) => o -> [Ggit.Flags.DiffOption] -> m () +setDiffOptionsFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val + +{- | +Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffOptionsFlags :: (IsDiffOptions o) => [Ggit.Flags.DiffOption] -> IO (GValueConstruct o) +constructDiffOptionsFlags val = B.Properties.constructObjectPropertyFlags "flags" val + +#if ENABLE_OVERLOADING +data DiffOptionsFlagsPropertyInfo +instance AttrInfo DiffOptionsFlagsPropertyInfo where + type AttrAllowedOps DiffOptionsFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffOptionsFlagsPropertyInfo = (~) [Ggit.Flags.DiffOption] + type AttrBaseTypeConstraint DiffOptionsFlagsPropertyInfo = IsDiffOptions + type AttrGetType DiffOptionsFlagsPropertyInfo = [Ggit.Flags.DiffOption] + type AttrLabel DiffOptionsFlagsPropertyInfo = "flags" + type AttrOrigin DiffOptionsFlagsPropertyInfo = DiffOptions + attrGet _ = getDiffOptionsFlags + attrSet _ = setDiffOptionsFlags + attrConstruct _ = constructDiffOptionsFlags + attrClear _ = undefined +#endif + +-- VVV Prop "n-context-lines" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@n-context-lines@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffOptions #nContextLines +@ +-} +getDiffOptionsNContextLines :: (MonadIO m, IsDiffOptions o) => o -> m Int32 +getDiffOptionsNContextLines obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "n-context-lines" + +{- | +Set the value of the “@n-context-lines@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffOptions [ #nContextLines 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffOptionsNContextLines :: (MonadIO m, IsDiffOptions o) => o -> Int32 -> m () +setDiffOptionsNContextLines obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "n-context-lines" val + +{- | +Construct a `GValueConstruct` with valid value for the “@n-context-lines@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffOptionsNContextLines :: (IsDiffOptions o) => Int32 -> IO (GValueConstruct o) +constructDiffOptionsNContextLines val = B.Properties.constructObjectPropertyInt32 "n-context-lines" val + +#if ENABLE_OVERLOADING +data DiffOptionsNContextLinesPropertyInfo +instance AttrInfo DiffOptionsNContextLinesPropertyInfo where + type AttrAllowedOps DiffOptionsNContextLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffOptionsNContextLinesPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint DiffOptionsNContextLinesPropertyInfo = IsDiffOptions + type AttrGetType DiffOptionsNContextLinesPropertyInfo = Int32 + type AttrLabel DiffOptionsNContextLinesPropertyInfo = "n-context-lines" + type AttrOrigin DiffOptionsNContextLinesPropertyInfo = DiffOptions + attrGet _ = getDiffOptionsNContextLines + attrSet _ = setDiffOptionsNContextLines + attrConstruct _ = constructDiffOptionsNContextLines + attrClear _ = undefined +#endif + +-- VVV Prop "n-interhunk-lines" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@n-interhunk-lines@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffOptions #nInterhunkLines +@ +-} +getDiffOptionsNInterhunkLines :: (MonadIO m, IsDiffOptions o) => o -> m Int32 +getDiffOptionsNInterhunkLines obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "n-interhunk-lines" + +{- | +Set the value of the “@n-interhunk-lines@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffOptions [ #nInterhunkLines 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffOptionsNInterhunkLines :: (MonadIO m, IsDiffOptions o) => o -> Int32 -> m () +setDiffOptionsNInterhunkLines obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "n-interhunk-lines" val + +{- | +Construct a `GValueConstruct` with valid value for the “@n-interhunk-lines@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffOptionsNInterhunkLines :: (IsDiffOptions o) => Int32 -> IO (GValueConstruct o) +constructDiffOptionsNInterhunkLines val = B.Properties.constructObjectPropertyInt32 "n-interhunk-lines" val + +#if ENABLE_OVERLOADING +data DiffOptionsNInterhunkLinesPropertyInfo +instance AttrInfo DiffOptionsNInterhunkLinesPropertyInfo where + type AttrAllowedOps DiffOptionsNInterhunkLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffOptionsNInterhunkLinesPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint DiffOptionsNInterhunkLinesPropertyInfo = IsDiffOptions + type AttrGetType DiffOptionsNInterhunkLinesPropertyInfo = Int32 + type AttrLabel DiffOptionsNInterhunkLinesPropertyInfo = "n-interhunk-lines" + type AttrOrigin DiffOptionsNInterhunkLinesPropertyInfo = DiffOptions + attrGet _ = getDiffOptionsNInterhunkLines + attrSet _ = setDiffOptionsNInterhunkLines + attrConstruct _ = constructDiffOptionsNInterhunkLines + attrClear _ = undefined +#endif + +-- VVV Prop "new-prefix" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just True,Just False) + +{- | +Get the value of the “@new-prefix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffOptions #newPrefix +@ +-} +getDiffOptionsNewPrefix :: (MonadIO m, IsDiffOptions o) => o -> m (Maybe T.Text) +getDiffOptionsNewPrefix obj = liftIO $ B.Properties.getObjectPropertyString obj "new-prefix" + +{- | +Set the value of the “@new-prefix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffOptions [ #newPrefix 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffOptionsNewPrefix :: (MonadIO m, IsDiffOptions o) => o -> T.Text -> m () +setDiffOptionsNewPrefix obj val = liftIO $ B.Properties.setObjectPropertyString obj "new-prefix" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@new-prefix@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffOptionsNewPrefix :: (IsDiffOptions o) => T.Text -> IO (GValueConstruct o) +constructDiffOptionsNewPrefix val = B.Properties.constructObjectPropertyString "new-prefix" (Just val) + +#if ENABLE_OVERLOADING +data DiffOptionsNewPrefixPropertyInfo +instance AttrInfo DiffOptionsNewPrefixPropertyInfo where + type AttrAllowedOps DiffOptionsNewPrefixPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffOptionsNewPrefixPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DiffOptionsNewPrefixPropertyInfo = IsDiffOptions + type AttrGetType DiffOptionsNewPrefixPropertyInfo = (Maybe T.Text) + type AttrLabel DiffOptionsNewPrefixPropertyInfo = "new-prefix" + type AttrOrigin DiffOptionsNewPrefixPropertyInfo = DiffOptions + attrGet _ = getDiffOptionsNewPrefix + attrSet _ = setDiffOptionsNewPrefix + attrConstruct _ = constructDiffOptionsNewPrefix + attrClear _ = undefined +#endif + +-- VVV Prop "old-prefix" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@old-prefix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffOptions #oldPrefix +@ +-} +getDiffOptionsOldPrefix :: (MonadIO m, IsDiffOptions o) => o -> m (Maybe T.Text) +getDiffOptionsOldPrefix obj = liftIO $ B.Properties.getObjectPropertyString obj "old-prefix" + +{- | +Set the value of the “@old-prefix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffOptions [ #oldPrefix 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffOptionsOldPrefix :: (MonadIO m, IsDiffOptions o) => o -> T.Text -> m () +setDiffOptionsOldPrefix obj val = liftIO $ B.Properties.setObjectPropertyString obj "old-prefix" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@old-prefix@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffOptionsOldPrefix :: (IsDiffOptions o) => T.Text -> IO (GValueConstruct o) +constructDiffOptionsOldPrefix val = B.Properties.constructObjectPropertyString "old-prefix" (Just val) + +#if ENABLE_OVERLOADING +data DiffOptionsOldPrefixPropertyInfo +instance AttrInfo DiffOptionsOldPrefixPropertyInfo where + type AttrAllowedOps DiffOptionsOldPrefixPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DiffOptionsOldPrefixPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DiffOptionsOldPrefixPropertyInfo = IsDiffOptions + type AttrGetType DiffOptionsOldPrefixPropertyInfo = (Maybe T.Text) + type AttrLabel DiffOptionsOldPrefixPropertyInfo = "old-prefix" + type AttrOrigin DiffOptionsOldPrefixPropertyInfo = DiffOptions + attrGet _ = getDiffOptionsOldPrefix + attrSet _ = setDiffOptionsOldPrefix + attrConstruct _ = constructDiffOptionsOldPrefix + attrClear _ = undefined +#endif + +-- VVV Prop "pathspec" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@pathspec@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' diffOptions #pathspec +@ +-} +getDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> m (Maybe [T.Text]) +getDiffOptionsPathspec obj = liftIO $ B.Properties.getObjectPropertyStringArray obj "pathspec" + +{- | +Set the value of the “@pathspec@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' diffOptions [ #pathspec 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> [T.Text] -> m () +setDiffOptionsPathspec obj val = liftIO $ B.Properties.setObjectPropertyStringArray obj "pathspec" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@pathspec@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDiffOptionsPathspec :: (IsDiffOptions o) => [T.Text] -> IO (GValueConstruct o) +constructDiffOptionsPathspec val = B.Properties.constructObjectPropertyStringArray "pathspec" (Just val) + +{- | +Set the value of the “@pathspec@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #pathspec +@ +-} +clearDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> m () +clearDiffOptionsPathspec obj = liftIO $ B.Properties.setObjectPropertyStringArray obj "pathspec" (Nothing :: Maybe [T.Text]) + +#if ENABLE_OVERLOADING +data DiffOptionsPathspecPropertyInfo +instance AttrInfo DiffOptionsPathspecPropertyInfo where + type AttrAllowedOps DiffOptionsPathspecPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DiffOptionsPathspecPropertyInfo = (~) [T.Text] + type AttrBaseTypeConstraint DiffOptionsPathspecPropertyInfo = IsDiffOptions + type AttrGetType DiffOptionsPathspecPropertyInfo = (Maybe [T.Text]) + type AttrLabel DiffOptionsPathspecPropertyInfo = "pathspec" + type AttrOrigin DiffOptionsPathspecPropertyInfo = DiffOptions + attrGet _ = getDiffOptionsPathspec + attrSet _ = setDiffOptionsPathspec + attrConstruct _ = constructDiffOptionsPathspec + attrClear _ = clearDiffOptionsPathspec +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffOptions +type instance O.AttributeList DiffOptions = DiffOptionsAttributeList +type DiffOptionsAttributeList = ('[ '("flags", DiffOptionsFlagsPropertyInfo), '("nContextLines", DiffOptionsNContextLinesPropertyInfo), '("nInterhunkLines", DiffOptionsNInterhunkLinesPropertyInfo), '("newPrefix", DiffOptionsNewPrefixPropertyInfo), '("oldPrefix", DiffOptionsOldPrefixPropertyInfo), '("pathspec", DiffOptionsPathspecPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +diffOptionsFlags :: AttrLabelProxy "flags" +diffOptionsFlags = AttrLabelProxy + +diffOptionsNContextLines :: AttrLabelProxy "nContextLines" +diffOptionsNContextLines = AttrLabelProxy + +diffOptionsNInterhunkLines :: AttrLabelProxy "nInterhunkLines" +diffOptionsNInterhunkLines = AttrLabelProxy + +diffOptionsNewPrefix :: AttrLabelProxy "newPrefix" +diffOptionsNewPrefix = AttrLabelProxy + +diffOptionsOldPrefix :: AttrLabelProxy "oldPrefix" +diffOptionsOldPrefix = AttrLabelProxy + +diffOptionsPathspec :: AttrLabelProxy "pathspec" +diffOptionsPathspec = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList DiffOptions = DiffOptionsSignalList +type DiffOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method DiffOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_options_new" ggit_diff_options_new :: + IO (Ptr DiffOptions) + +{- | +Create a new diff options object. +-} +diffOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe DiffOptions) + {- ^ __Returns:__ a 'GI.Ggit.Objects.DiffOptions.DiffOptions' or 'Nothing'. -} +diffOptionsNew = liftIO $ do + result <- ggit_diff_options_new + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject DiffOptions) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method DiffOptions::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffOption"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_options_get_flags" ggit_diff_options_get_flags :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + IO CUInt + +{- | +Get the diff flags. +-} +diffOptionsGetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> m [Ggit.Flags.DiffOption] + {- ^ __Returns:__ a 'GI.Ggit.Flags.DiffOption'. -} +diffOptionsGetFlags options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_options_get_flags options' + let result' = wordToGFlags result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data DiffOptionsGetFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.DiffOption]), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetFlagsMethodInfo a signature where + overloadedMethod _ = diffOptionsGetFlags + +#endif + +-- method DiffOptions::get_n_context_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_options_get_n_context_lines" ggit_diff_options_get_n_context_lines :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + IO Int32 + +{- | +Get the number of context lines to include in the diff. +-} +diffOptionsGetNContextLines :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> m Int32 + {- ^ __Returns:__ the number of context lines. -} +diffOptionsGetNContextLines options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_options_get_n_context_lines options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffOptionsGetNContextLinesMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetNContextLinesMethodInfo a signature where + overloadedMethod _ = diffOptionsGetNContextLines + +#endif + +-- method DiffOptions::get_n_interhunk_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_options_get_n_interhunk_lines" ggit_diff_options_get_n_interhunk_lines :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + IO Int32 + +{- | +Get the number of interhunk lines to include in the diff. +-} +diffOptionsGetNInterhunkLines :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> m Int32 + {- ^ __Returns:__ the number of lines. -} +diffOptionsGetNInterhunkLines options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_options_get_n_interhunk_lines options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data DiffOptionsGetNInterhunkLinesMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetNInterhunkLinesMethodInfo a signature where + overloadedMethod _ = diffOptionsGetNInterhunkLines + +#endif + +-- method DiffOptions::get_new_prefix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_options_get_new_prefix" ggit_diff_options_get_new_prefix :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + IO CString + +{- | +Get the diff new-prefix string. +-} +diffOptionsGetNewPrefix :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the new-prefix string or 'Nothing'. -} +diffOptionsGetNewPrefix options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_options_get_new_prefix options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffOptionsGetNewPrefixMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetNewPrefixMethodInfo a signature where + overloadedMethod _ = diffOptionsGetNewPrefix + +#endif + +-- method DiffOptions::get_old_prefix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_options_get_old_prefix" ggit_diff_options_get_old_prefix :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + IO CString + +{- | +Get the diff old-prefix string. +-} +diffOptionsGetOldPrefix :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the old-prefix string or 'Nothing'. -} +diffOptionsGetOldPrefix options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_options_get_old_prefix options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffOptionsGetOldPrefixMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetOldPrefixMethodInfo a signature where + overloadedMethod _ = diffOptionsGetOldPrefix + +#endif + +-- method DiffOptions::get_pathspec +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_options_get_pathspec" ggit_diff_options_get_pathspec :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + IO (Ptr CString) + +{- | +Get the pathspec. +-} +diffOptionsGetPathspec :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ the pathspec or 'Nothing'. -} +diffOptionsGetPathspec options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_diff_options_get_pathspec options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data DiffOptionsGetPathspecMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsGetPathspecMethodInfo a signature where + overloadedMethod _ = diffOptionsGetPathspec + +#endif + +-- method DiffOptions::set_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "DiffOption"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOption.", 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_options_set_flags" ggit_diff_options_set_flags :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "DiffOption"}) + IO () + +{- | +Set the diff flags. +-} +diffOptionsSetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> [Ggit.Flags.DiffOption] + {- ^ /@flags@/: a 'GI.Ggit.Flags.DiffOption'. -} + -> m () +diffOptionsSetFlags options flags = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + let flags' = gflagsToWord flags + ggit_diff_options_set_flags options' flags' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffOptionsSetFlagsMethodInfo +instance (signature ~ ([Ggit.Flags.DiffOption] -> m ()), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsSetFlagsMethodInfo a signature where + overloadedMethod _ = diffOptionsSetFlags + +#endif + +-- method DiffOptions::set_n_context_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of lines.", 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_options_set_n_context_lines" ggit_diff_options_set_n_context_lines :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Int32 -> -- n : TBasicType TInt + IO () + +{- | +Set the number of context lines to include in the diff. +-} +diffOptionsSetNContextLines :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> Int32 + {- ^ /@n@/: the number of lines. -} + -> m () +diffOptionsSetNContextLines options n = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_options_set_n_context_lines options' n + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffOptionsSetNContextLinesMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsSetNContextLinesMethodInfo a signature where + overloadedMethod _ = diffOptionsSetNContextLines + +#endif + +-- method DiffOptions::set_n_interhunk_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of lines.", 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_options_set_n_interhunk_lines" ggit_diff_options_set_n_interhunk_lines :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Int32 -> -- n : TBasicType TInt + IO () + +{- | +Set the number of interhunk lines to include in the diff. +-} +diffOptionsSetNInterhunkLines :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> Int32 + {- ^ /@n@/: the number of lines. -} + -> m () +diffOptionsSetNInterhunkLines options n = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_diff_options_set_n_interhunk_lines options' n + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data DiffOptionsSetNInterhunkLinesMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsSetNInterhunkLinesMethodInfo a signature where + overloadedMethod _ = diffOptionsSetNInterhunkLines + +#endif + +-- method DiffOptions::set_new_prefix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prefix", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the prefix.", 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_options_set_new_prefix" ggit_diff_options_set_new_prefix :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + CString -> -- prefix : TBasicType TUTF8 + IO () + +{- | +Set the diff new-prefix string. +-} +diffOptionsSetNewPrefix :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> T.Text + {- ^ /@prefix@/: the prefix. -} + -> m () +diffOptionsSetNewPrefix options prefix = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + prefix' <- textToCString prefix + ggit_diff_options_set_new_prefix options' prefix' + touchManagedPtr options + freeMem prefix' + return () + +#if ENABLE_OVERLOADING +data DiffOptionsSetNewPrefixMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsSetNewPrefixMethodInfo a signature where + overloadedMethod _ = diffOptionsSetNewPrefix + +#endif + +-- method DiffOptions::set_old_prefix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prefix", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the prefix.", 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_options_set_old_prefix" ggit_diff_options_set_old_prefix :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + CString -> -- prefix : TBasicType TUTF8 + IO () + +{- | +Get the diff old-prefix string. +-} +diffOptionsSetOldPrefix :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> T.Text + {- ^ /@prefix@/: the prefix. -} + -> m () +diffOptionsSetOldPrefix options prefix = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + prefix' <- textToCString prefix + ggit_diff_options_set_old_prefix options' prefix' + touchManagedPtr options + freeMem prefix' + return () + +#if ENABLE_OVERLOADING +data DiffOptionsSetOldPrefixMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsSetOldPrefixMethodInfo a signature where + overloadedMethod _ = diffOptionsSetOldPrefix + +#endif + +-- method DiffOptions::set_pathspec +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pathspec", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the pathspec.", 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_options_set_pathspec" ggit_diff_options_set_pathspec :: + Ptr DiffOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Ptr CString -> -- pathspec : TCArray True (-1) (-1) (TBasicType TUTF8) + IO () + +{- | +Set the pathspec. +-} +diffOptionsSetPathspec :: + (B.CallStack.HasCallStack, MonadIO m, IsDiffOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions'. -} + -> Maybe ([T.Text]) + {- ^ /@pathspec@/: the pathspec. -} + -> m () +diffOptionsSetPathspec options pathspec = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybePathspec <- case pathspec of + Nothing -> return nullPtr + Just jPathspec -> do + jPathspec' <- packZeroTerminatedUTF8CArray jPathspec + return jPathspec' + ggit_diff_options_set_pathspec options' maybePathspec + touchManagedPtr options + mapZeroTerminatedCArray freeMem maybePathspec + freeMem maybePathspec + return () + +#if ENABLE_OVERLOADING +data DiffOptionsSetPathspecMethodInfo +instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsDiffOptions a) => O.MethodInfo DiffOptionsSetPathspecMethodInfo a signature where + overloadedMethod _ = diffOptionsSetPathspec + +#endif + + diff --git a/GI/Ggit/Objects/DiffOptions.hs-boot b/GI/Ggit/Objects/DiffOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/DiffOptions.hs-boot @@ -0,0 +1,83 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.DiffOptions 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 + +newtype DiffOptions = DiffOptions (ManagedPtr DiffOptions) +instance GObject DiffOptions where +class (GObject o, O.IsDescendantOf DiffOptions o) => IsDiffOptions o +instance (GObject o, O.IsDescendantOf DiffOptions o) => IsDiffOptions o +instance O.HasParentTypes DiffOptions +#if ENABLE_OVERLOADING +data DiffOptionsFlagsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsNContextLinesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsNInterhunkLinesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsNewPrefixPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsOldPrefixPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsPathspecPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsGetNContextLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsGetNInterhunkLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsGetNewPrefixMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsGetOldPrefixMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsGetPathspecMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsSetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsSetNContextLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsSetNInterhunkLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsSetNewPrefixMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsSetOldPrefixMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffOptionsSetPathspecMethodInfo +#endif diff --git a/GI/Ggit/Objects/Index.hs b/GI/Ggit/Objects/Index.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Index.hs @@ -0,0 +1,858 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents an index object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Index + ( + +-- * Exported types + Index(..) , + IsIndex , + toIndex , + noIndex , + + + -- * Methods +-- ** add #method:add# + +#if ENABLE_OVERLOADING + IndexAddMethodInfo , +#endif + indexAdd , + + +-- ** addFile #method:addFile# + +#if ENABLE_OVERLOADING + IndexAddFileMethodInfo , +#endif + indexAddFile , + + +-- ** addPath #method:addPath# + +#if ENABLE_OVERLOADING + IndexAddPathMethodInfo , +#endif + indexAddPath , + + +-- ** getEntries #method:getEntries# + +#if ENABLE_OVERLOADING + IndexGetEntriesMethodInfo , +#endif + indexGetEntries , + + +-- ** getEntriesResolveUndo #method:getEntriesResolveUndo# + +#if ENABLE_OVERLOADING + IndexGetEntriesResolveUndoMethodInfo , +#endif + indexGetEntriesResolveUndo , + + +-- ** getOwner #method:getOwner# + +#if ENABLE_OVERLOADING + IndexGetOwnerMethodInfo , +#endif + indexGetOwner , + + +-- ** hasConflicts #method:hasConflicts# + +#if ENABLE_OVERLOADING + IndexHasConflictsMethodInfo , +#endif + indexHasConflicts , + + +-- ** open #method:open# + + indexOpen , + + +-- ** read #method:read# + +#if ENABLE_OVERLOADING + IndexReadMethodInfo , +#endif + indexRead , + + +-- ** remove #method:remove# + +#if ENABLE_OVERLOADING + IndexRemoveMethodInfo , +#endif + indexRemove , + + +-- ** write #method:write# + +#if ENABLE_OVERLOADING + IndexWriteMethodInfo , +#endif + indexWrite , + + +-- ** writeTree #method:writeTree# + +#if ENABLE_OVERLOADING + IndexWriteTreeMethodInfo , +#endif + indexWriteTree , + + +-- ** writeTreeTo #method:writeTreeTo# + +#if ENABLE_OVERLOADING + IndexWriteTreeToMethodInfo , +#endif + indexWriteTreeTo , + + + + + -- * Properties +-- ** file #attr:file# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + IndexFilePropertyInfo , +#endif + constructIndexFile , + getIndexFile , +#if ENABLE_OVERLOADING + indexFile , +#endif + + + + + ) 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.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntries as Ggit.IndexEntries +import {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntriesResolveUndo as Ggit.IndexEntriesResolveUndo +import {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntry as Ggit.IndexEntry +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Interfaces.Initable as Gio.Initable + +-- | Memory-managed wrapper type. +newtype Index = Index (ManagedPtr Index) +foreign import ccall "ggit_index_get_type" + c_ggit_index_get_type :: IO GType + +instance GObject Index where + gobjectType = c_ggit_index_get_type + + +-- | Type class for types which can be safely cast to `Index`, for instance with `toIndex`. +class (GObject o, O.IsDescendantOf Index o) => IsIndex o +instance (GObject o, O.IsDescendantOf Index o) => IsIndex o + +instance O.HasParentTypes Index +type instance O.ParentTypes Index = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `Index`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toIndex :: (MonadIO m, IsIndex o) => o -> m Index +toIndex = liftIO . unsafeCastTo Index + +-- | A convenience alias for `Nothing` :: `Maybe` `Index`. +noIndex :: Maybe Index +noIndex = Nothing + +#if ENABLE_OVERLOADING +type family ResolveIndexMethod (t :: Symbol) (o :: *) :: * where + ResolveIndexMethod "add" o = IndexAddMethodInfo + ResolveIndexMethod "addFile" o = IndexAddFileMethodInfo + ResolveIndexMethod "addPath" o = IndexAddPathMethodInfo + ResolveIndexMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveIndexMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveIndexMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveIndexMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveIndexMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveIndexMethod "hasConflicts" o = IndexHasConflictsMethodInfo + ResolveIndexMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveIndexMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveIndexMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveIndexMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveIndexMethod "read" o = IndexReadMethodInfo + ResolveIndexMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveIndexMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveIndexMethod "remove" o = IndexRemoveMethodInfo + ResolveIndexMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveIndexMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveIndexMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveIndexMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveIndexMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveIndexMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveIndexMethod "write" o = IndexWriteMethodInfo + ResolveIndexMethod "writeTree" o = IndexWriteTreeMethodInfo + ResolveIndexMethod "writeTreeTo" o = IndexWriteTreeToMethodInfo + ResolveIndexMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveIndexMethod "getEntries" o = IndexGetEntriesMethodInfo + ResolveIndexMethod "getEntriesResolveUndo" o = IndexGetEntriesResolveUndoMethodInfo + ResolveIndexMethod "getOwner" o = IndexGetOwnerMethodInfo + ResolveIndexMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveIndexMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveIndexMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveIndexMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveIndexMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIndexMethod t Index, O.MethodInfo info Index p) => OL.IsLabel t (Index -> 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 + +-- VVV Prop "file" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@file@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' index #file +@ +-} +getIndexFile :: (MonadIO m, IsIndex o) => o -> m (Maybe Gio.File.File) +getIndexFile obj = liftIO $ B.Properties.getObjectPropertyObject obj "file" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@file@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructIndexFile :: (IsIndex o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructIndexFile val = B.Properties.constructObjectPropertyObject "file" (Just val) + +#if ENABLE_OVERLOADING +data IndexFilePropertyInfo +instance AttrInfo IndexFilePropertyInfo where + type AttrAllowedOps IndexFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint IndexFilePropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint IndexFilePropertyInfo = IsIndex + type AttrGetType IndexFilePropertyInfo = (Maybe Gio.File.File) + type AttrLabel IndexFilePropertyInfo = "file" + type AttrOrigin IndexFilePropertyInfo = Index + attrGet _ = getIndexFile + attrSet _ = undefined + attrConstruct _ = constructIndexFile + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Index +type instance O.AttributeList Index = IndexAttributeList +type IndexAttributeList = ('[ '("file", IndexFilePropertyInfo), '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +indexFile :: AttrLabelProxy "file" +indexFile = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Index = IndexSignalList +type IndexSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Index::add +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_add" ggit_index_add :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr Ggit.IndexEntry.IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Add a file to the index. +-} +indexAdd :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> Ggit.IndexEntry.IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexAdd idx entry = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + entry' <- unsafeManagedPtrGetPtr entry + onException (do + _ <- propagateGError $ ggit_index_add idx' entry' + touchManagedPtr idx + touchManagedPtr entry + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexAddMethodInfo +instance (signature ~ (Ggit.IndexEntry.IndexEntry -> m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexAddMethodInfo a signature where + overloadedMethod _ = indexAdd + +#endif + +-- method Index::add_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "file to add.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_add_file" ggit_index_add_file :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Add a file to the index. The specified file must be in the working directory +and must exist and be readable. +-} +indexAddFile :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a, Gio.File.IsFile b) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> b + {- ^ /@file@/: file to add. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexAddFile idx file = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + file' <- unsafeManagedPtrCastPtr file + onException (do + _ <- propagateGError $ ggit_index_add_file idx' file' + touchManagedPtr idx + touchManagedPtr file + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexAddFileMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsIndex a, Gio.File.IsFile b) => O.MethodInfo IndexAddFileMethodInfo a signature where + overloadedMethod _ = indexAddFile + +#endif + +-- method Index::add_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path to the file to add.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_add_path" ggit_index_add_path :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + CString -> -- path : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Add a file to the index by path. You can specify both relative paths +(to the working directory) and absolute paths. Absolute paths however must +reside in the working directory. The specified path must exist and must be +readable. +-} +indexAddPath :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> T.Text + {- ^ /@path@/: path to the file to add. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexAddPath idx path = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + path' <- textToCString path + onException (do + _ <- propagateGError $ ggit_index_add_path idx' path' + touchManagedPtr idx + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data IndexAddPathMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexAddPathMethodInfo a signature where + overloadedMethod _ = indexAddPath + +#endif + +-- method Index::get_entries +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntries"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_get_entries" ggit_index_get_entries :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + IO (Ptr Ggit.IndexEntries.IndexEntries) + +{- | +Get the index entries enumerator. +-} +indexGetEntries :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> m (Maybe Ggit.IndexEntries.IndexEntries) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntries.IndexEntries' or 'Nothing'. -} +indexGetEntries idx = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + result <- ggit_index_get_entries idx' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntries.IndexEntries) result' + return result'' + touchManagedPtr idx + return maybeResult + +#if ENABLE_OVERLOADING +data IndexGetEntriesMethodInfo +instance (signature ~ (m (Maybe Ggit.IndexEntries.IndexEntries)), MonadIO m, IsIndex a) => O.MethodInfo IndexGetEntriesMethodInfo a signature where + overloadedMethod _ = indexGetEntries + +#endif + +-- method Index::get_entries_resolve_undo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_get_entries_resolve_undo" ggit_index_get_entries_resolve_undo :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + IO (Ptr Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo) + +{- | +Get the resolve undo entries enumerator. +-} +indexGetEntriesResolveUndo :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> m (Maybe Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo' or 'Nothing'. -} +indexGetEntriesResolveUndo idx = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + result <- ggit_index_get_entries_resolve_undo idx' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo) result' + return result'' + touchManagedPtr idx + return maybeResult + +#if ENABLE_OVERLOADING +data IndexGetEntriesResolveUndoMethodInfo +instance (signature ~ (m (Maybe Ggit.IndexEntriesResolveUndo.IndexEntriesResolveUndo)), MonadIO m, IsIndex a) => O.MethodInfo IndexGetEntriesResolveUndoMethodInfo a signature where + overloadedMethod _ = indexGetEntriesResolveUndo + +#endif + +-- method Index::get_owner +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_get_owner" ggit_index_get_owner :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + IO (Ptr Ggit.Repository.Repository) + +{- | +Get the 'GI.Ggit.Objects.Repository.Repository' that owns the index. +-} +indexGetOwner :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> m (Maybe Ggit.Repository.Repository) + {- ^ __Returns:__ the 'GI.Ggit.Objects.Repository.Repository' that owns this index or 'Nothing'. -} +indexGetOwner idx = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + result <- ggit_index_get_owner idx' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Repository.Repository) result' + return result'' + touchManagedPtr idx + return maybeResult + +#if ENABLE_OVERLOADING +data IndexGetOwnerMethodInfo +instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsIndex a) => O.MethodInfo IndexGetOwnerMethodInfo a signature where + overloadedMethod _ = indexGetOwner + +#endif + +-- method Index::has_conflicts +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_has_conflicts" ggit_index_has_conflicts :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + IO CInt + +{- | +Get whether the index has any conflicts. +-} +indexHasConflicts :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the index has any conflicts, 'False' otherwise. -} +indexHasConflicts idx = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + result <- ggit_index_has_conflicts idx' + let result' = (/= 0) result + touchManagedPtr idx + return result' + +#if ENABLE_OVERLOADING +data IndexHasConflictsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsIndex a) => O.MethodInfo IndexHasConflictsMethodInfo a signature where + overloadedMethod _ = indexHasConflicts + +#endif + +-- method Index::read +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "force", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "force read even if there are in-memory changes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_read" ggit_index_read :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + CInt -> -- force : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Update the contents of an existing index object in memory by reading from +the hard disk. + +If /@force@/ is true, this performs a \"hard\" read that discards in-memory +changes and always reloads the on-disk index data. If there is no on-disk +version, the index will be cleared. + +If /@force@/ is false, this does a \"soft\" read that reloads the index data from +disk only if it has changed since the last time it was loaded. Purely +in-memory index data will be untouched. Be aware: if there are changes on +disk, unwritten in-memory changes are discarded. +-} +indexRead :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> Bool + {- ^ /@force@/: force read even if there are in-memory changes. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexRead idx force = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + let force' = (fromIntegral . fromEnum) force + onException (do + _ <- propagateGError $ ggit_index_read idx' force' + touchManagedPtr idx + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexReadMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexReadMethodInfo a signature where + overloadedMethod _ = indexRead + +#endif + +-- method Index::remove +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file to search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stage", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stage to search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_remove" ggit_index_remove :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Int32 -> -- stage : TBasicType TInt + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Remove a file from the index (specified by position). +-} +indexRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a, Gio.File.IsFile b) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> b + {- ^ /@file@/: the file to search. -} + -> Int32 + {- ^ /@stage@/: the stage to search. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexRemove idx file stage = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + file' <- unsafeManagedPtrCastPtr file + onException (do + _ <- propagateGError $ ggit_index_remove idx' file' stage + touchManagedPtr idx + touchManagedPtr file + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexRemoveMethodInfo +instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsIndex a, Gio.File.IsFile b) => O.MethodInfo IndexRemoveMethodInfo a signature where + overloadedMethod _ = indexRemove + +#endif + +-- method Index::write +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_write" ggit_index_write :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Write an existing index object from memory back to disk using an atomic file +lock. +-} +indexWrite :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexWrite idx = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + onException (do + _ <- propagateGError $ ggit_index_write idx' + touchManagedPtr idx + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexWriteMethodInfo +instance (signature ~ (m ()), MonadIO m, IsIndex a) => O.MethodInfo IndexWriteMethodInfo a signature where + overloadedMethod _ = indexWrite + +#endif + +-- method Index::write_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_write_tree" ggit_index_write_tree :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Write a new tree object to disk containing a representation of the current +state of the index. The index must be associated to an existing repository +and must not contain any files in conflict. You can use the resulting tree +to for instance create a commit. +-} +indexWriteTree :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexWriteTree idx = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + onException (do + result <- propagateGError $ ggit_index_write_tree idx' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr idx + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexWriteTreeMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsIndex a) => O.MethodInfo IndexWriteTreeMethodInfo a signature where + overloadedMethod _ = indexWriteTree + +#endif + +-- method Index::write_tree_to +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "idx", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndex.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_write_tree_to" ggit_index_write_tree_to :: + Ptr Index -> -- idx : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Write a new tree object to /@repository@/ containing a representation of the current +state of the index. The index must not contain any files in conflict. You can use +the resulting tree to for instance create a commit. +-} +indexWriteTreeTo :: + (B.CallStack.HasCallStack, MonadIO m, IsIndex a, Ggit.Repository.IsRepository b) => + a + {- ^ /@idx@/: a 'GI.Ggit.Objects.Index.Index'. -} + -> b + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexWriteTreeTo idx repository = liftIO $ do + idx' <- unsafeManagedPtrCastPtr idx + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_index_write_tree_to idx' repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr idx + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexWriteTreeToMethodInfo +instance (signature ~ (b -> m (Maybe Ggit.OId.OId)), MonadIO m, IsIndex a, Ggit.Repository.IsRepository b) => O.MethodInfo IndexWriteTreeToMethodInfo a signature where + overloadedMethod _ = indexWriteTreeTo + +#endif + +-- method Index::open +-- method type : MemberFunction +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Index"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_open" ggit_index_open :: + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Index) + +{- | +Create a new bare Git index object as a memory representation of the Git +index file in /@file@/, without a repository to back it. +-} +indexOpen :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@file@/: a 'GI.Gio.Interfaces.File.File'. -} + -> m (Maybe Index) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Index.Index' or 'Nothing' if an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexOpen file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + onException (do + result <- propagateGError $ ggit_index_open file' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Index) result' + return result'' + touchManagedPtr file + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/Ggit/Objects/Index.hs-boot b/GI/Ggit/Objects/Index.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Index.hs-boot @@ -0,0 +1,68 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Index 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 + +newtype Index = Index (ManagedPtr Index) +instance GObject Index where +class (GObject o, O.IsDescendantOf Index o) => IsIndex o +instance (GObject o, O.IsDescendantOf Index o) => IsIndex o +instance O.HasParentTypes Index +#if ENABLE_OVERLOADING +data IndexFilePropertyInfo +#endif +#if ENABLE_OVERLOADING +data IndexAddMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexAddFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexAddPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexGetEntriesMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexGetEntriesResolveUndoMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexGetOwnerMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexHasConflictsMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexReadMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexWriteMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexWriteTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexWriteTreeToMethodInfo +#endif diff --git a/GI/Ggit/Objects/Native.hs b/GI/Ggit/Objects/Native.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Native.hs @@ -0,0 +1,166 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a generic native object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Native + ( + +-- * Exported types + Native(..) , + IsNative , + toNative , + noNative , + + + -- * Properties +-- ** native #attr:native# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + NativeNativePropertyInfo , +#endif + constructNativeNative , +#if ENABLE_OVERLOADING + nativeNative , +#endif + + + + + ) 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.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase + +-- | Memory-managed wrapper type. +newtype Native = Native (ManagedPtr Native) +foreign import ccall "ggit_native_get_type" + c_ggit_native_get_type :: IO GType + +instance GObject Native where + gobjectType = c_ggit_native_get_type + + +-- | Type class for types which can be safely cast to `Native`, for instance with `toNative`. +class (GObject o, O.IsDescendantOf Native o) => IsNative o +instance (GObject o, O.IsDescendantOf Native o) => IsNative o + +instance O.HasParentTypes Native +type instance O.ParentTypes Native = '[Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Native`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toNative :: (MonadIO m, IsNative o) => o -> m Native +toNative = liftIO . unsafeCastTo Native + +-- | A convenience alias for `Nothing` :: `Maybe` `Native`. +noNative :: Maybe Native +noNative = Nothing + +#if ENABLE_OVERLOADING +type family ResolveNativeMethod (t :: Symbol) (o :: *) :: * where + ResolveNativeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveNativeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveNativeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveNativeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveNativeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveNativeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveNativeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveNativeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveNativeMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveNativeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveNativeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveNativeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveNativeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveNativeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveNativeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveNativeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveNativeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveNativeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveNativeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveNativeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveNativeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveNativeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNativeMethod t Native, O.MethodInfo info Native p) => OL.IsLabel t (Native -> 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 + +-- VVV Prop "native" + -- Type: TBasicType TPtr + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Construct a `GValueConstruct` with valid value for the “@native@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructNativeNative :: (IsNative o) => Ptr () -> IO (GValueConstruct o) +constructNativeNative val = B.Properties.constructObjectPropertyPtr "native" val + +#if ENABLE_OVERLOADING +data NativeNativePropertyInfo +instance AttrInfo NativeNativePropertyInfo where + type AttrAllowedOps NativeNativePropertyInfo = '[ 'AttrConstruct] + type AttrSetTypeConstraint NativeNativePropertyInfo = (~) (Ptr ()) + type AttrBaseTypeConstraint NativeNativePropertyInfo = IsNative + type AttrGetType NativeNativePropertyInfo = () + type AttrLabel NativeNativePropertyInfo = "native" + type AttrOrigin NativeNativePropertyInfo = Native + attrGet _ = undefined + attrSet _ = undefined + attrConstruct _ = constructNativeNative + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Native +type instance O.AttributeList Native = NativeAttributeList +type NativeAttributeList = ('[ '("native", NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +nativeNative :: AttrLabelProxy "native" +nativeNative = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Native = NativeSignalList +type NativeSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/Ggit/Objects/Native.hs-boot b/GI/Ggit/Objects/Native.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Native.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Native 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 + +newtype Native = Native (ManagedPtr Native) +instance GObject Native where +class (GObject o, O.IsDescendantOf Native o) => IsNative o +instance (GObject o, O.IsDescendantOf Native o) => IsNative o +instance O.HasParentTypes Native +#if ENABLE_OVERLOADING +data NativeNativePropertyInfo +#endif diff --git a/GI/Ggit/Objects/Object.hs b/GI/Ggit/Objects/Object.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Object.hs @@ -0,0 +1,221 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a generic object in a repository. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Object + ( + +-- * Exported types + Object(..) , + IsObject , + toObject , + noObject , + + + -- * Methods +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + ObjectGetIdMethodInfo , +#endif + objectGetId , + + +-- ** getOwner #method:getOwner# + +#if ENABLE_OVERLOADING + ObjectGetOwnerMethodInfo , +#endif + objectGetOwner , + + + + + ) 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.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype Object = Object (ManagedPtr Object) +foreign import ccall "ggit_object_get_type" + c_ggit_object_get_type :: IO GType + +instance GObject Object where + gobjectType = c_ggit_object_get_type + + +-- | Type class for types which can be safely cast to `Object`, for instance with `toObject`. +class (GObject o, O.IsDescendantOf Object o) => IsObject o +instance (GObject o, O.IsDescendantOf Object o) => IsObject o + +instance O.HasParentTypes Object +type instance O.ParentTypes Object = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Object`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toObject :: (MonadIO m, IsObject o) => o -> m Object +toObject = liftIO . unsafeCastTo Object + +-- | A convenience alias for `Nothing` :: `Maybe` `Object`. +noObject :: Maybe Object +noObject = Nothing + +#if ENABLE_OVERLOADING +type family ResolveObjectMethod (t :: Symbol) (o :: *) :: * where + ResolveObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveObjectMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveObjectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveObjectMethod "getId" o = ObjectGetIdMethodInfo + ResolveObjectMethod "getOwner" o = ObjectGetOwnerMethodInfo + ResolveObjectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveObjectMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveObjectMethod t Object, O.MethodInfo info Object p) => OL.IsLabel t (Object -> 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 Object +type instance O.AttributeList Object = ObjectAttributeList +type ObjectAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Object = ObjectSignalList +type ObjectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Object::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_object_get_id" ggit_object_get_id :: + Ptr Object -> -- object : TInterface (Name {namespace = "Ggit", name = "Object"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the 'GI.Ggit.Structs.OId.OId' of /@object@/. +-} +objectGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + {- ^ /@object@/: a 'GI.Ggit.Objects.Object.Object'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the 'GI.Ggit.Structs.OId.OId' of the object or 'Nothing'. -} +objectGetId object = liftIO $ do + object' <- unsafeManagedPtrCastPtr object + result <- ggit_object_get_id object' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr object + return maybeResult + +#if ENABLE_OVERLOADING +data ObjectGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsObject a) => O.MethodInfo ObjectGetIdMethodInfo a signature where + overloadedMethod _ = objectGetId + +#endif + +-- method Object::get_owner +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_object_get_owner" ggit_object_get_owner :: + Ptr Object -> -- object : TInterface (Name {namespace = "Ggit", name = "Object"}) + IO (Ptr Ggit.Repository.Repository) + +{- | +Gets the 'GI.Ggit.Objects.Repository.Repository' that owns /@object@/. +-} +objectGetOwner :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + {- ^ /@object@/: a 'GI.Ggit.Objects.Object.Object'. -} + -> m (Maybe Ggit.Repository.Repository) + {- ^ __Returns:__ the 'GI.Ggit.Objects.Repository.Repository' that owns this object or 'Nothing'. +The returned value must be free\'d calling 'GI.GObject.Objects.Object.objectUnref'. -} +objectGetOwner object = liftIO $ do + object' <- unsafeManagedPtrCastPtr object + result <- ggit_object_get_owner object' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Repository.Repository) result' + return result'' + touchManagedPtr object + return maybeResult + +#if ENABLE_OVERLOADING +data ObjectGetOwnerMethodInfo +instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsObject a) => O.MethodInfo ObjectGetOwnerMethodInfo a signature where + overloadedMethod _ = objectGetOwner + +#endif + + diff --git a/GI/Ggit/Objects/Object.hs-boot b/GI/Ggit/Objects/Object.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Object.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Object 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 + +newtype Object = Object (ManagedPtr Object) +instance GObject Object where +class (GObject o, O.IsDescendantOf Object o) => IsObject o +instance (GObject o, O.IsDescendantOf Object o) => IsObject o +instance O.HasParentTypes Object +#if ENABLE_OVERLOADING +data ObjectGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data ObjectGetOwnerMethodInfo +#endif diff --git a/GI/Ggit/Objects/ObjectFactoryBase.hs b/GI/Ggit/Objects/ObjectFactoryBase.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/ObjectFactoryBase.hs @@ -0,0 +1,121 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the base type for objects created by an object factory. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.ObjectFactoryBase + ( + +-- * Exported types + ObjectFactoryBase(..) , + IsObjectFactoryBase , + toObjectFactoryBase , + noObjectFactoryBase , + + + ) 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 + +-- | Memory-managed wrapper type. +newtype ObjectFactoryBase = ObjectFactoryBase (ManagedPtr ObjectFactoryBase) +foreign import ccall "ggit_object_factory_base_get_type" + c_ggit_object_factory_base_get_type :: IO GType + +instance GObject ObjectFactoryBase where + gobjectType = c_ggit_object_factory_base_get_type + + +-- | Type class for types which can be safely cast to `ObjectFactoryBase`, for instance with `toObjectFactoryBase`. +class (GObject o, O.IsDescendantOf ObjectFactoryBase o) => IsObjectFactoryBase o +instance (GObject o, O.IsDescendantOf ObjectFactoryBase o) => IsObjectFactoryBase o + +instance O.HasParentTypes ObjectFactoryBase +type instance O.ParentTypes ObjectFactoryBase = '[GObject.Object.Object] + +-- | Cast to `ObjectFactoryBase`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toObjectFactoryBase :: (MonadIO m, IsObjectFactoryBase o) => o -> m ObjectFactoryBase +toObjectFactoryBase = liftIO . unsafeCastTo ObjectFactoryBase + +-- | A convenience alias for `Nothing` :: `Maybe` `ObjectFactoryBase`. +noObjectFactoryBase :: Maybe ObjectFactoryBase +noObjectFactoryBase = Nothing + +#if ENABLE_OVERLOADING +type family ResolveObjectFactoryBaseMethod (t :: Symbol) (o :: *) :: * where + ResolveObjectFactoryBaseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveObjectFactoryBaseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveObjectFactoryBaseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveObjectFactoryBaseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveObjectFactoryBaseMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveObjectFactoryBaseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveObjectFactoryBaseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveObjectFactoryBaseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveObjectFactoryBaseMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveObjectFactoryBaseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveObjectFactoryBaseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveObjectFactoryBaseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveObjectFactoryBaseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveObjectFactoryBaseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveObjectFactoryBaseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveObjectFactoryBaseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveObjectFactoryBaseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveObjectFactoryBaseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveObjectFactoryBaseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveObjectFactoryBaseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveObjectFactoryBaseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveObjectFactoryBaseMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveObjectFactoryBaseMethod t ObjectFactoryBase, O.MethodInfo info ObjectFactoryBase p) => OL.IsLabel t (ObjectFactoryBase -> 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 ObjectFactoryBase +type instance O.AttributeList ObjectFactoryBase = ObjectFactoryBaseAttributeList +type ObjectFactoryBaseAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList ObjectFactoryBase = ObjectFactoryBaseSignalList +type ObjectFactoryBaseSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/Ggit/Objects/ObjectFactoryBase.hs-boot b/GI/Ggit/Objects/ObjectFactoryBase.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/ObjectFactoryBase.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.ObjectFactoryBase 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 + +newtype ObjectFactoryBase = ObjectFactoryBase (ManagedPtr ObjectFactoryBase) +instance GObject ObjectFactoryBase where +class (GObject o, O.IsDescendantOf ObjectFactoryBase o) => IsObjectFactoryBase o +instance (GObject o, O.IsDescendantOf ObjectFactoryBase o) => IsObjectFactoryBase o +instance O.HasParentTypes ObjectFactoryBase diff --git a/GI/Ggit/Objects/ProxyOptions.hs b/GI/Ggit/Objects/ProxyOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/ProxyOptions.hs @@ -0,0 +1,157 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git proxy options. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.ProxyOptions + ( + +-- * Exported types + ProxyOptions(..) , + IsProxyOptions , + toProxyOptions , + noProxyOptions , + + + -- * Methods +-- ** new #method:new# + + proxyOptionsNew , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype ProxyOptions = ProxyOptions (ManagedPtr ProxyOptions) +foreign import ccall "ggit_proxy_options_get_type" + c_ggit_proxy_options_get_type :: IO GType + +instance GObject ProxyOptions where + gobjectType = c_ggit_proxy_options_get_type + + +-- | Type class for types which can be safely cast to `ProxyOptions`, for instance with `toProxyOptions`. +class (GObject o, O.IsDescendantOf ProxyOptions o) => IsProxyOptions o +instance (GObject o, O.IsDescendantOf ProxyOptions o) => IsProxyOptions o + +instance O.HasParentTypes ProxyOptions +type instance O.ParentTypes ProxyOptions = '[GObject.Object.Object] + +-- | Cast to `ProxyOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toProxyOptions :: (MonadIO m, IsProxyOptions o) => o -> m ProxyOptions +toProxyOptions = liftIO . unsafeCastTo ProxyOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `ProxyOptions`. +noProxyOptions :: Maybe ProxyOptions +noProxyOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveProxyOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveProxyOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveProxyOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveProxyOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveProxyOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveProxyOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveProxyOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveProxyOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveProxyOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveProxyOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveProxyOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveProxyOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveProxyOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveProxyOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveProxyOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveProxyOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveProxyOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveProxyOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveProxyOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveProxyOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveProxyOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveProxyOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveProxyOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveProxyOptionsMethod t ProxyOptions, O.MethodInfo info ProxyOptions p) => OL.IsLabel t (ProxyOptions -> 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 ProxyOptions +type instance O.AttributeList ProxyOptions = ProxyOptionsAttributeList +type ProxyOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList ProxyOptions = ProxyOptionsSignalList +type ProxyOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method ProxyOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "ProxyOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_proxy_options_new" ggit_proxy_options_new :: + IO (Ptr ProxyOptions) + +{- | +Create a new proxy options object. +-} +proxyOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe ProxyOptions) + {- ^ __Returns:__ a 'GI.Ggit.Objects.ProxyOptions.ProxyOptions'. -} +proxyOptionsNew = liftIO $ do + result <- ggit_proxy_options_new + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject ProxyOptions) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/Ggit/Objects/ProxyOptions.hs-boot b/GI/Ggit/Objects/ProxyOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/ProxyOptions.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.ProxyOptions 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 + +newtype ProxyOptions = ProxyOptions (ManagedPtr ProxyOptions) +instance GObject ProxyOptions where +class (GObject o, O.IsDescendantOf ProxyOptions o) => IsProxyOptions o +instance (GObject o, O.IsDescendantOf ProxyOptions o) => IsProxyOptions o +instance O.HasParentTypes ProxyOptions diff --git a/GI/Ggit/Objects/PushOptions.hs b/GI/Ggit/Objects/PushOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/PushOptions.hs @@ -0,0 +1,317 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git push options. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.PushOptions + ( + +-- * Exported types + PushOptions(..) , + IsPushOptions , + toPushOptions , + noPushOptions , + + + -- * Methods +-- ** getParallelism #method:getParallelism# + +#if ENABLE_OVERLOADING + PushOptionsGetParallelismMethodInfo , +#endif + pushOptionsGetParallelism , + + +-- ** new #method:new# + + pushOptionsNew , + + +-- ** setParallelism #method:setParallelism# + +#if ENABLE_OVERLOADING + PushOptionsSetParallelismMethodInfo , +#endif + pushOptionsSetParallelism , + + + + + -- * Properties +-- ** parallelism #attr:parallelism# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + PushOptionsParallelismPropertyInfo , +#endif + constructPushOptionsParallelism , + getPushOptionsParallelism , +#if ENABLE_OVERLOADING + pushOptionsParallelism , +#endif + setPushOptionsParallelism , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype PushOptions = PushOptions (ManagedPtr PushOptions) +foreign import ccall "ggit_push_options_get_type" + c_ggit_push_options_get_type :: IO GType + +instance GObject PushOptions where + gobjectType = c_ggit_push_options_get_type + + +-- | Type class for types which can be safely cast to `PushOptions`, for instance with `toPushOptions`. +class (GObject o, O.IsDescendantOf PushOptions o) => IsPushOptions o +instance (GObject o, O.IsDescendantOf PushOptions o) => IsPushOptions o + +instance O.HasParentTypes PushOptions +type instance O.ParentTypes PushOptions = '[GObject.Object.Object] + +-- | Cast to `PushOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPushOptions :: (MonadIO m, IsPushOptions o) => o -> m PushOptions +toPushOptions = liftIO . unsafeCastTo PushOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `PushOptions`. +noPushOptions :: Maybe PushOptions +noPushOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePushOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolvePushOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePushOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePushOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePushOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePushOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePushOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePushOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePushOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePushOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePushOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePushOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePushOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePushOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePushOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePushOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePushOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePushOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePushOptionsMethod "getParallelism" o = PushOptionsGetParallelismMethodInfo + ResolvePushOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePushOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePushOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePushOptionsMethod "setParallelism" o = PushOptionsSetParallelismMethodInfo + ResolvePushOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePushOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePushOptionsMethod t PushOptions, O.MethodInfo info PushOptions p) => OL.IsLabel t (PushOptions -> 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 + +-- VVV Prop "parallelism" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@parallelism@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pushOptions #parallelism +@ +-} +getPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> m Int32 +getPushOptionsParallelism obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "parallelism" + +{- | +Set the value of the “@parallelism@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pushOptions [ #parallelism 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> Int32 -> m () +setPushOptionsParallelism obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "parallelism" val + +{- | +Construct a `GValueConstruct` with valid value for the “@parallelism@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPushOptionsParallelism :: (IsPushOptions o) => Int32 -> IO (GValueConstruct o) +constructPushOptionsParallelism val = B.Properties.constructObjectPropertyInt32 "parallelism" val + +#if ENABLE_OVERLOADING +data PushOptionsParallelismPropertyInfo +instance AttrInfo PushOptionsParallelismPropertyInfo where + type AttrAllowedOps PushOptionsParallelismPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PushOptionsParallelismPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint PushOptionsParallelismPropertyInfo = IsPushOptions + type AttrGetType PushOptionsParallelismPropertyInfo = Int32 + type AttrLabel PushOptionsParallelismPropertyInfo = "parallelism" + type AttrOrigin PushOptionsParallelismPropertyInfo = PushOptions + attrGet _ = getPushOptionsParallelism + attrSet _ = setPushOptionsParallelism + attrConstruct _ = constructPushOptionsParallelism + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PushOptions +type instance O.AttributeList PushOptions = PushOptionsAttributeList +type PushOptionsAttributeList = ('[ '("parallelism", PushOptionsParallelismPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +pushOptionsParallelism :: AttrLabelProxy "parallelism" +pushOptionsParallelism = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList PushOptions = PushOptionsSignalList +type PushOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method PushOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "PushOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_push_options_new" ggit_push_options_new :: + IO (Ptr PushOptions) + +{- | +Create a new push options object. +-} +pushOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe PushOptions) + {- ^ __Returns:__ a 'GI.Ggit.Objects.PushOptions.PushOptions' or 'Nothing'. -} +pushOptionsNew = liftIO $ do + result <- ggit_push_options_new + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject PushOptions) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method PushOptions::get_parallelism +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "PushOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPushOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_push_options_get_parallelism" ggit_push_options_get_parallelism :: + Ptr PushOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"}) + IO Int32 + +{- | +Get the number of parallel threads to use when creating the pack file +to push. The special value 0 indicates that the number of threads will +be automatically detected. +-} +pushOptionsGetParallelism :: + (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.PushOptions.PushOptions'. -} + -> m Int32 + {- ^ __Returns:__ the number of parallel threads, or 0 for auto-detect. -} +pushOptionsGetParallelism options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_push_options_get_parallelism options' + touchManagedPtr options + return result + +#if ENABLE_OVERLOADING +data PushOptionsGetParallelismMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsPushOptions a) => O.MethodInfo PushOptionsGetParallelismMethodInfo a signature where + overloadedMethod _ = pushOptionsGetParallelism + +#endif + +-- method PushOptions::set_parallelism +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "PushOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPushOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parallelism", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of threads, or 0 for auto-detect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_push_options_set_parallelism" ggit_push_options_set_parallelism :: + Ptr PushOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"}) + Int32 -> -- parallelism : TBasicType TInt + IO () + +{- | +Set the number of parallel threads to use when creating the pack file +to push. The special value 0 can be specified for /@parallelism@/ indicating that +the number of threads will be automatically detected. +-} +pushOptionsSetParallelism :: + (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.PushOptions.PushOptions'. -} + -> Int32 + {- ^ /@parallelism@/: the number of threads, or 0 for auto-detect. -} + -> m () +pushOptionsSetParallelism options parallelism = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + ggit_push_options_set_parallelism options' parallelism + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data PushOptionsSetParallelismMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsPushOptions a) => O.MethodInfo PushOptionsSetParallelismMethodInfo a signature where + overloadedMethod _ = pushOptionsSetParallelism + +#endif + + diff --git a/GI/Ggit/Objects/PushOptions.hs-boot b/GI/Ggit/Objects/PushOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/PushOptions.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.PushOptions 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 + +newtype PushOptions = PushOptions (ManagedPtr PushOptions) +instance GObject PushOptions where +class (GObject o, O.IsDescendantOf PushOptions o) => IsPushOptions o +instance (GObject o, O.IsDescendantOf PushOptions o) => IsPushOptions o +instance O.HasParentTypes PushOptions +#if ENABLE_OVERLOADING +data PushOptionsParallelismPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PushOptionsGetParallelismMethodInfo +#endif +#if ENABLE_OVERLOADING +data PushOptionsSetParallelismMethodInfo +#endif diff --git a/GI/Ggit/Objects/Rebase.hs b/GI/Ggit/Objects/Rebase.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Rebase.hs @@ -0,0 +1,507 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a rebase object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Rebase + ( + +-- * Exported types + Rebase(..) , + IsRebase , + toRebase , + noRebase , + + + -- * Methods +-- ** abort #method:abort# + +#if ENABLE_OVERLOADING + RebaseAbortMethodInfo , +#endif + rebaseAbort , + + +-- ** commit #method:commit# + +#if ENABLE_OVERLOADING + RebaseCommitMethodInfo , +#endif + rebaseCommit , + + +-- ** finish #method:finish# + +#if ENABLE_OVERLOADING + RebaseFinishMethodInfo , +#endif + rebaseFinish , + + +-- ** getOperationByIndex #method:getOperationByIndex# + +#if ENABLE_OVERLOADING + RebaseGetOperationByIndexMethodInfo , +#endif + rebaseGetOperationByIndex , + + +-- ** getOperationEntryCount #method:getOperationEntryCount# + +#if ENABLE_OVERLOADING + RebaseGetOperationEntryCountMethodInfo , +#endif + rebaseGetOperationEntryCount , + + +-- ** getOperationIndex #method:getOperationIndex# + +#if ENABLE_OVERLOADING + RebaseGetOperationIndexMethodInfo , +#endif + rebaseGetOperationIndex , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + RebaseNextMethodInfo , +#endif + rebaseNext , + + + + + ) 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.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.RebaseOperation as Ggit.RebaseOperation + +-- | Memory-managed wrapper type. +newtype Rebase = Rebase (ManagedPtr Rebase) +foreign import ccall "ggit_rebase_get_type" + c_ggit_rebase_get_type :: IO GType + +instance GObject Rebase where + gobjectType = c_ggit_rebase_get_type + + +-- | Type class for types which can be safely cast to `Rebase`, for instance with `toRebase`. +class (GObject o, O.IsDescendantOf Rebase o) => IsRebase o +instance (GObject o, O.IsDescendantOf Rebase o) => IsRebase o + +instance O.HasParentTypes Rebase +type instance O.ParentTypes Rebase = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Rebase`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRebase :: (MonadIO m, IsRebase o) => o -> m Rebase +toRebase = liftIO . unsafeCastTo Rebase + +-- | A convenience alias for `Nothing` :: `Maybe` `Rebase`. +noRebase :: Maybe Rebase +noRebase = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRebaseMethod (t :: Symbol) (o :: *) :: * where + ResolveRebaseMethod "abort" o = RebaseAbortMethodInfo + ResolveRebaseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRebaseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRebaseMethod "commit" o = RebaseCommitMethodInfo + ResolveRebaseMethod "finish" o = RebaseFinishMethodInfo + ResolveRebaseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRebaseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRebaseMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRebaseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRebaseMethod "next" o = RebaseNextMethodInfo + ResolveRebaseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRebaseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRebaseMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRebaseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRebaseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRebaseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRebaseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRebaseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRebaseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRebaseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRebaseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRebaseMethod "getOperationByIndex" o = RebaseGetOperationByIndexMethodInfo + ResolveRebaseMethod "getOperationEntryCount" o = RebaseGetOperationEntryCountMethodInfo + ResolveRebaseMethod "getOperationIndex" o = RebaseGetOperationIndexMethodInfo + ResolveRebaseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRebaseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRebaseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRebaseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRebaseMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRebaseMethod t Rebase, O.MethodInfo info Rebase p) => OL.IsLabel t (Rebase -> 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 Rebase +type instance O.AttributeList Rebase = RebaseAttributeList +type RebaseAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Rebase = RebaseSignalList +type RebaseSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Rebase::abort +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase", argType = TInterface (Name {namespace = "Ggit", name = "Rebase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebase.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_rebase_abort" ggit_rebase_abort :: + Ptr Rebase -> -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Aborts a rebase that is currently in progress, resetting the repository +and working directory to their state before rebase began. +-} +rebaseAbort :: + (B.CallStack.HasCallStack, MonadIO m, IsRebase a) => + a + {- ^ /@rebase@/: a 'GI.Ggit.Objects.Rebase.Rebase'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +rebaseAbort rebase = liftIO $ do + rebase' <- unsafeManagedPtrCastPtr rebase + onException (do + propagateGError $ ggit_rebase_abort rebase' + touchManagedPtr rebase + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RebaseAbortMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRebase a) => O.MethodInfo RebaseAbortMethodInfo a signature where + overloadedMethod _ = rebaseAbort + +#endif + +-- method Rebase::commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase", argType = TInterface (Name {namespace = "Ggit", name = "Rebase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebase.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitSignature or %NULL to keep the author from\nthe original commit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the message for this commit, or %NULL to use\nthe message from the original commit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_rebase_commit" ggit_rebase_commit :: + Ptr Rebase -> -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"}) + Ptr Ggit.Signature.Signature -> -- author : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.Signature.Signature -> -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Commits the current patch. You must have resolved any conflicts that +were introduced during the patch application from the 'GI.Ggit.Objects.Rebase.rebaseNext' +invocation. +-} +rebaseCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRebase a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => + a + {- ^ /@rebase@/: a 'GI.Ggit.Objects.Rebase.Rebase'. -} + -> Maybe (b) + {- ^ /@author@/: a 'GI.Ggit.Objects.Signature.Signature' or 'Nothing' to keep the author from +the original commit. -} + -> c + {- ^ /@committer@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> Maybe (T.Text) + {- ^ /@message@/: the message for this commit, or 'Nothing' to use +the message from the original commit. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' of the newly created commit or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +rebaseCommit rebase author committer message = liftIO $ do + rebase' <- unsafeManagedPtrCastPtr rebase + maybeAuthor <- case author of + Nothing -> return nullPtr + Just jAuthor -> do + jAuthor' <- unsafeManagedPtrCastPtr jAuthor + return jAuthor' + committer' <- unsafeManagedPtrCastPtr committer + maybeMessage <- case message of + Nothing -> return nullPtr + Just jMessage -> do + jMessage' <- textToCString jMessage + return jMessage' + onException (do + result <- propagateGError $ ggit_rebase_commit rebase' maybeAuthor committer' maybeMessage + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr rebase + whenJust author touchManagedPtr + touchManagedPtr committer + freeMem maybeMessage + return maybeResult + ) (do + freeMem maybeMessage + ) + +#if ENABLE_OVERLOADING +data RebaseCommitMethodInfo +instance (signature ~ (Maybe (b) -> c -> Maybe (T.Text) -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRebase a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => O.MethodInfo RebaseCommitMethodInfo a signature where + overloadedMethod _ = rebaseCommit + +#endif + +-- method Rebase::finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase", argType = TInterface (Name {namespace = "Ggit", name = "Rebase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebase.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the identity that is finishing the rebase or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_rebase_finish" ggit_rebase_finish :: + Ptr Rebase -> -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"}) + Ptr Ggit.Signature.Signature -> -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Finishes a rebase that is currently in progress once all patches have +been applied. +-} +rebaseFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsRebase a, Ggit.Signature.IsSignature b) => + a + {- ^ /@rebase@/: a 'GI.Ggit.Objects.Rebase.Rebase'. -} + -> Maybe (b) + {- ^ /@signature@/: the identity that is finishing the rebase or 'Nothing'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +rebaseFinish rebase signature = liftIO $ do + rebase' <- unsafeManagedPtrCastPtr rebase + maybeSignature <- case signature of + Nothing -> return nullPtr + Just jSignature -> do + jSignature' <- unsafeManagedPtrCastPtr jSignature + return jSignature' + onException (do + propagateGError $ ggit_rebase_finish rebase' maybeSignature + touchManagedPtr rebase + whenJust signature touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RebaseFinishMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRebase a, Ggit.Signature.IsSignature b) => O.MethodInfo RebaseFinishMethodInfo a signature where + overloadedMethod _ = rebaseFinish + +#endif + +-- method Rebase::get_operation_by_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase", argType = TInterface (Name {namespace = "Ggit", name = "Rebase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebase.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The index of the rebase operation to retrieve.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RebaseOperation"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_get_operation_by_index" ggit_rebase_get_operation_by_index :: + Ptr Rebase -> -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"}) + Word64 -> -- idx : TBasicType TUInt64 + IO (Ptr Ggit.RebaseOperation.RebaseOperation) + +{- | +Gets the rebase operation specified by /@idx@/. +-} +rebaseGetOperationByIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsRebase a) => + a + {- ^ /@rebase@/: a 'GI.Ggit.Objects.Rebase.Rebase'. -} + -> Word64 + {- ^ /@idx@/: The index of the rebase operation to retrieve. -} + -> m (Maybe Ggit.RebaseOperation.RebaseOperation) + {- ^ __Returns:__ The rebase operation or 'Nothing' if /@idx@/ was out of bounds. -} +rebaseGetOperationByIndex rebase idx = liftIO $ do + rebase' <- unsafeManagedPtrCastPtr rebase + result <- ggit_rebase_get_operation_by_index rebase' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.RebaseOperation.RebaseOperation) result' + return result'' + touchManagedPtr rebase + return maybeResult + +#if ENABLE_OVERLOADING +data RebaseGetOperationByIndexMethodInfo +instance (signature ~ (Word64 -> m (Maybe Ggit.RebaseOperation.RebaseOperation)), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationByIndexMethodInfo a signature where + overloadedMethod _ = rebaseGetOperationByIndex + +#endif + +-- method Rebase::get_operation_entry_count +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase", argType = TInterface (Name {namespace = "Ggit", name = "Rebase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebase.", 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_rebase_get_operation_entry_count" ggit_rebase_get_operation_entry_count :: + Ptr Rebase -> -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"}) + IO Word64 + +{- | +Gets the count of rebase operations that are to be applied. +-} +rebaseGetOperationEntryCount :: + (B.CallStack.HasCallStack, MonadIO m, IsRebase a) => + a + {- ^ /@rebase@/: a 'GI.Ggit.Objects.Rebase.Rebase'. -} + -> m Word64 + {- ^ __Returns:__ the count of rebase operations that are to be applied. -} +rebaseGetOperationEntryCount rebase = liftIO $ do + rebase' <- unsafeManagedPtrCastPtr rebase + result <- ggit_rebase_get_operation_entry_count rebase' + touchManagedPtr rebase + return result + +#if ENABLE_OVERLOADING +data RebaseGetOperationEntryCountMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationEntryCountMethodInfo a signature where + overloadedMethod _ = rebaseGetOperationEntryCount + +#endif + +-- method Rebase::get_operation_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase", argType = TInterface (Name {namespace = "Ggit", name = "Rebase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebase.", 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_rebase_get_operation_index" ggit_rebase_get_operation_index :: + Ptr Rebase -> -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"}) + IO Word64 + +{- | +Gets the index of the rebase operation that is currently being applied. +If the first operation has not yet been applied (because you have +called 'GI.Ggit.Objects.Repository.repositoryRebaseInit' but not yet 'GI.Ggit.Objects.Rebase.rebaseNext') +then this returns /@gGITREBASENOOPERATION@/. +-} +rebaseGetOperationIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsRebase a) => + a + {- ^ /@rebase@/: a 'GI.Ggit.Objects.Rebase.Rebase'. -} + -> m Word64 + {- ^ __Returns:__ The index of the rebase operation currently being applied. -} +rebaseGetOperationIndex rebase = liftIO $ do + rebase' <- unsafeManagedPtrCastPtr rebase + result <- ggit_rebase_get_operation_index rebase' + touchManagedPtr rebase + return result + +#if ENABLE_OVERLOADING +data RebaseGetOperationIndexMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsRebase a) => O.MethodInfo RebaseGetOperationIndexMethodInfo a signature where + overloadedMethod _ = rebaseGetOperationIndex + +#endif + +-- method Rebase::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase", argType = TInterface (Name {namespace = "Ggit", name = "Rebase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebase.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RebaseOperation"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_rebase_next" ggit_rebase_next :: + Ptr Rebase -> -- rebase : TInterface (Name {namespace = "Ggit", name = "Rebase"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.RebaseOperation.RebaseOperation) + +{- | +Performs the next rebase operation and returns the information about it. +If the operation is one that applies a patch (which is any operation except +/@gGITREBASEOPERATIONEXEC@/) then the patch will be applied and the index and +working directory will be updated with the changes. If there are conflicts, +you will need to address those before committing the changes. +-} +rebaseNext :: + (B.CallStack.HasCallStack, MonadIO m, IsRebase a) => + a + {- ^ /@rebase@/: a 'GI.Ggit.Objects.Rebase.Rebase'. -} + -> m (Maybe Ggit.RebaseOperation.RebaseOperation) + {- ^ __Returns:__ the rebase operation that is to be performed next or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +rebaseNext rebase = liftIO $ do + rebase' <- unsafeManagedPtrCastPtr rebase + onException (do + result <- propagateGError $ ggit_rebase_next rebase' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.RebaseOperation.RebaseOperation) result' + return result'' + touchManagedPtr rebase + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RebaseNextMethodInfo +instance (signature ~ (m (Maybe Ggit.RebaseOperation.RebaseOperation)), MonadIO m, IsRebase a) => O.MethodInfo RebaseNextMethodInfo a signature where + overloadedMethod _ = rebaseNext + +#endif + + diff --git a/GI/Ggit/Objects/Rebase.hs-boot b/GI/Ggit/Objects/Rebase.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Rebase.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Rebase 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 + +newtype Rebase = Rebase (ManagedPtr Rebase) +instance GObject Rebase where +class (GObject o, O.IsDescendantOf Rebase o) => IsRebase o +instance (GObject o, O.IsDescendantOf Rebase o) => IsRebase o +instance O.HasParentTypes Rebase +#if ENABLE_OVERLOADING +data RebaseAbortMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseGetOperationByIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseGetOperationEntryCountMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseGetOperationIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseNextMethodInfo +#endif diff --git a/GI/Ggit/Objects/Ref.hs b/GI/Ggit/Objects/Ref.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Ref.hs @@ -0,0 +1,1197 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Reprensents a git reference. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Ref + ( + +-- * Exported types + Ref(..) , + IsRef , + toRef , + noRef , + + + -- * Methods +-- ** delete #method:delete# + +#if ENABLE_OVERLOADING + RefDeleteMethodInfo , +#endif + refDelete , + + +-- ** deleteLog #method:deleteLog# + +#if ENABLE_OVERLOADING + RefDeleteLogMethodInfo , +#endif + refDeleteLog , + + +-- ** getLog #method:getLog# + +#if ENABLE_OVERLOADING + RefGetLogMethodInfo , +#endif + refGetLog , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + RefGetNameMethodInfo , +#endif + refGetName , + + +-- ** getOwner #method:getOwner# + +#if ENABLE_OVERLOADING + RefGetOwnerMethodInfo , +#endif + refGetOwner , + + +-- ** getReferenceType #method:getReferenceType# + +#if ENABLE_OVERLOADING + RefGetReferenceTypeMethodInfo , +#endif + refGetReferenceType , + + +-- ** getShorthand #method:getShorthand# + +#if ENABLE_OVERLOADING + RefGetShorthandMethodInfo , +#endif + refGetShorthand , + + +-- ** getSymbolicTarget #method:getSymbolicTarget# + +#if ENABLE_OVERLOADING + RefGetSymbolicTargetMethodInfo , +#endif + refGetSymbolicTarget , + + +-- ** getTarget #method:getTarget# + +#if ENABLE_OVERLOADING + RefGetTargetMethodInfo , +#endif + refGetTarget , + + +-- ** hasLog #method:hasLog# + +#if ENABLE_OVERLOADING + RefHasLogMethodInfo , +#endif + refHasLog , + + +-- ** isBranch #method:isBranch# + +#if ENABLE_OVERLOADING + RefIsBranchMethodInfo , +#endif + refIsBranch , + + +-- ** isNote #method:isNote# + +#if ENABLE_OVERLOADING + RefIsNoteMethodInfo , +#endif + refIsNote , + + +-- ** isRemote #method:isRemote# + +#if ENABLE_OVERLOADING + RefIsRemoteMethodInfo , +#endif + refIsRemote , + + +-- ** isTag #method:isTag# + +#if ENABLE_OVERLOADING + RefIsTagMethodInfo , +#endif + refIsTag , + + +-- ** isValidName #method:isValidName# + + refIsValidName , + + +-- ** lookup #method:lookup# + +#if ENABLE_OVERLOADING + RefLookupMethodInfo , +#endif + refLookup , + + +-- ** rename #method:rename# + +#if ENABLE_OVERLOADING + RefRenameMethodInfo , +#endif + refRename , + + +-- ** resolve #method:resolve# + +#if ENABLE_OVERLOADING + RefResolveMethodInfo , +#endif + refResolve , + + +-- ** setSymbolicTarget #method:setSymbolicTarget# + +#if ENABLE_OVERLOADING + RefSetSymbolicTargetMethodInfo , +#endif + refSetSymbolicTarget , + + +-- ** setTarget #method:setTarget# + +#if ENABLE_OVERLOADING + RefSetTargetMethodInfo , +#endif + refSetTarget , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + RefToStringMethodInfo , +#endif + refToString , + + + + + ) 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.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.Reflog as Ggit.Reflog + +-- | Memory-managed wrapper type. +newtype Ref = Ref (ManagedPtr Ref) +foreign import ccall "ggit_ref_get_type" + c_ggit_ref_get_type :: IO GType + +instance GObject Ref where + gobjectType = c_ggit_ref_get_type + + +-- | Type class for types which can be safely cast to `Ref`, for instance with `toRef`. +class (GObject o, O.IsDescendantOf Ref o) => IsRef o +instance (GObject o, O.IsDescendantOf Ref o) => IsRef o + +instance O.HasParentTypes Ref +type instance O.ParentTypes Ref = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Ref`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRef :: (MonadIO m, IsRef o) => o -> m Ref +toRef = liftIO . unsafeCastTo Ref + +-- | A convenience alias for `Nothing` :: `Maybe` `Ref`. +noRef :: Maybe Ref +noRef = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRefMethod (t :: Symbol) (o :: *) :: * where + ResolveRefMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRefMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRefMethod "delete" o = RefDeleteMethodInfo + ResolveRefMethod "deleteLog" o = RefDeleteLogMethodInfo + ResolveRefMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRefMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRefMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRefMethod "hasLog" o = RefHasLogMethodInfo + ResolveRefMethod "isBranch" o = RefIsBranchMethodInfo + ResolveRefMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRefMethod "isNote" o = RefIsNoteMethodInfo + ResolveRefMethod "isRemote" o = RefIsRemoteMethodInfo + ResolveRefMethod "isTag" o = RefIsTagMethodInfo + ResolveRefMethod "lookup" o = RefLookupMethodInfo + ResolveRefMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRefMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRefMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRefMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRefMethod "rename" o = RefRenameMethodInfo + ResolveRefMethod "resolve" o = RefResolveMethodInfo + ResolveRefMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRefMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRefMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRefMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRefMethod "toString" o = RefToStringMethodInfo + ResolveRefMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRefMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRefMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRefMethod "getLog" o = RefGetLogMethodInfo + ResolveRefMethod "getName" o = RefGetNameMethodInfo + ResolveRefMethod "getOwner" o = RefGetOwnerMethodInfo + ResolveRefMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRefMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRefMethod "getReferenceType" o = RefGetReferenceTypeMethodInfo + ResolveRefMethod "getShorthand" o = RefGetShorthandMethodInfo + ResolveRefMethod "getSymbolicTarget" o = RefGetSymbolicTargetMethodInfo + ResolveRefMethod "getTarget" o = RefGetTargetMethodInfo + ResolveRefMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRefMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRefMethod "setSymbolicTarget" o = RefSetSymbolicTargetMethodInfo + ResolveRefMethod "setTarget" o = RefSetTargetMethodInfo + ResolveRefMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRefMethod t Ref, O.MethodInfo info Ref p) => OL.IsLabel t (Ref -> 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 Ref +type instance O.AttributeList Ref = RefAttributeList +type RefAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Ref = RefSignalList +type RefSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Ref::delete +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_delete" ggit_ref_delete :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Deletes /@ref@/. + +This method works for both direct and symbolic references. + +The reference will be immediately removed on disk and from +memory. The given reference pointer will no longer be valid. +-} +refDelete :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +refDelete ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + onException (do + propagateGError $ ggit_ref_delete ref' + touchManagedPtr ref + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RefDeleteMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRef a) => O.MethodInfo RefDeleteMethodInfo a signature where + overloadedMethod _ = refDelete + +#endif + +-- method Ref::delete_log +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_delete_log" ggit_ref_delete_log :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Deletes the log for /@ref@/, on error /@error@/ is set. +-} +refDeleteLog :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +refDeleteLog ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + onException (do + propagateGError $ ggit_ref_delete_log ref' + touchManagedPtr ref + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RefDeleteLogMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRef a) => O.MethodInfo RefDeleteLogMethodInfo a signature where + overloadedMethod _ = refDeleteLog + +#endif + +-- method Ref::get_log +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Reflog"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_get_log" ggit_ref_get_log :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Reflog.Reflog) + +{- | +Gets the 'GI.Ggit.Structs.Reflog.Reflog' for /@ref@/. The reflog will be created if it doesn\'t exist +yet. +-} +refGetLog :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe Ggit.Reflog.Reflog) + {- ^ __Returns:__ the reflog or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +refGetLog ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + onException (do + result <- propagateGError $ ggit_ref_get_log ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.Reflog.Reflog) result' + return result'' + touchManagedPtr ref + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RefGetLogMethodInfo +instance (signature ~ (m (Maybe Ggit.Reflog.Reflog)), MonadIO m, IsRef a) => O.MethodInfo RefGetLogMethodInfo a signature where + overloadedMethod _ = refGetLog + +#endif + +-- method Ref::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_get_name" ggit_ref_get_name :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CString + +{- | +Gets the full name of /@ref@/. +-} +refGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the full name of a reference or 'Nothing'. -} +refGetName ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_get_name ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr ref + return maybeResult + +#if ENABLE_OVERLOADING +data RefGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.MethodInfo RefGetNameMethodInfo a signature where + overloadedMethod _ = refGetName + +#endif + +-- method Ref::get_owner +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_get_owner" ggit_ref_get_owner :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO (Ptr Ggit.Repository.Repository) + +{- | +Gets the repository where /@ref@/ resides. +-} +refGetOwner :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe Ggit.Repository.Repository) + {- ^ __Returns:__ the repository where a reference resides or 'Nothing'. -} +refGetOwner ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_get_owner ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Repository.Repository) result' + return result'' + touchManagedPtr ref + return maybeResult + +#if ENABLE_OVERLOADING +data RefGetOwnerMethodInfo +instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsRef a) => O.MethodInfo RefGetOwnerMethodInfo a signature where + overloadedMethod _ = refGetOwner + +#endif + +-- method Ref::get_reference_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RefType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_get_reference_type" ggit_ref_get_reference_type :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CUInt + +{- | +Gets the type of /@ref@/. Either direct (@/GGIT_REF_OID/@) or +symbolic (@/GGIT_REF_SYMBOLIC/@). +-} +refGetReferenceType :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m Ggit.Enums.RefType + {- ^ __Returns:__ the type of a reference. -} +refGetReferenceType ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_get_reference_type ref' + let result' = (toEnum . fromIntegral) result + touchManagedPtr ref + return result' + +#if ENABLE_OVERLOADING +data RefGetReferenceTypeMethodInfo +instance (signature ~ (m Ggit.Enums.RefType), MonadIO m, IsRef a) => O.MethodInfo RefGetReferenceTypeMethodInfo a signature where + overloadedMethod _ = refGetReferenceType + +#endif + +-- method Ref::get_shorthand +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_get_shorthand" ggit_ref_get_shorthand :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CString + +{- | +Gets the shorthand name of /@ref@/. +-} +refGetShorthand :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the shorthand name of a reference or 'Nothing'. -} +refGetShorthand ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_get_shorthand ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr ref + return maybeResult + +#if ENABLE_OVERLOADING +data RefGetShorthandMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.MethodInfo RefGetShorthandMethodInfo a signature where + overloadedMethod _ = refGetShorthand + +#endif + +-- method Ref::get_symbolic_target +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_get_symbolic_target" ggit_ref_get_symbolic_target :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CString + +{- | +Get full name to the reference pointed to by a symbolic reference. +Only available if the reference is symbolic. +-} +refGetSymbolicTarget :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name if available, 'Nothing' otherwise. -} +refGetSymbolicTarget ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_get_symbolic_target ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr ref + return maybeResult + +#if ENABLE_OVERLOADING +data RefGetSymbolicTargetMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.MethodInfo RefGetSymbolicTargetMethodInfo a signature where + overloadedMethod _ = refGetSymbolicTarget + +#endif + +-- method Ref::get_target +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_get_target" ggit_ref_get_target :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the OID pointed to by a direct reference. +Only available if the reference is direct (i.e. an object id reference, +not a symbolic one). +-} +refGetTarget :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a new oid if available, 'Nothing' otherwise. -} +refGetTarget ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_get_target ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr ref + return maybeResult + +#if ENABLE_OVERLOADING +data RefGetTargetMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsRef a) => O.MethodInfo RefGetTargetMethodInfo a signature where + overloadedMethod _ = refGetTarget + +#endif + +-- method Ref::has_log +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_has_log" ggit_ref_has_log :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CInt + +{- | +Get whether /@ref@/ has an existing log. +-} +refHasLog :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m Bool + {- ^ __Returns:__ 'True' if /@ref@/ has a log, 'False' otherwise. -} +refHasLog ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_has_log ref' + let result' = (/= 0) result + touchManagedPtr ref + return result' + +#if ENABLE_OVERLOADING +data RefHasLogMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.MethodInfo RefHasLogMethodInfo a signature where + overloadedMethod _ = refHasLog + +#endif + +-- method Ref::is_branch +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_is_branch" ggit_ref_is_branch :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CInt + +{- | +Check whether the reference is a branch. +-} +refIsBranch :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the reference is a branch, 'False' otherwise. -} +refIsBranch ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_is_branch ref' + let result' = (/= 0) result + touchManagedPtr ref + return result' + +#if ENABLE_OVERLOADING +data RefIsBranchMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.MethodInfo RefIsBranchMethodInfo a signature where + overloadedMethod _ = refIsBranch + +#endif + +-- method Ref::is_note +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_is_note" ggit_ref_is_note :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CInt + +{- | +Check whether the reference is a note. +-} +refIsNote :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the reference is a note, 'False' otherwise. -} +refIsNote ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_is_note ref' + let result' = (/= 0) result + touchManagedPtr ref + return result' + +#if ENABLE_OVERLOADING +data RefIsNoteMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.MethodInfo RefIsNoteMethodInfo a signature where + overloadedMethod _ = refIsNote + +#endif + +-- method Ref::is_remote +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_is_remote" ggit_ref_is_remote :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CInt + +{- | +Check whether the reference is a remote. +-} +refIsRemote :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the reference is a remote, 'False' otherwise. -} +refIsRemote ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_is_remote ref' + let result' = (/= 0) result + touchManagedPtr ref + return result' + +#if ENABLE_OVERLOADING +data RefIsRemoteMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.MethodInfo RefIsRemoteMethodInfo a signature where + overloadedMethod _ = refIsRemote + +#endif + +-- method Ref::is_tag +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_is_tag" ggit_ref_is_tag :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CInt + +{- | +Check whether the reference is a tag. +-} +refIsTag :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the reference is a tag, 'False' otherwise. -} +refIsTag ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_is_tag ref' + let result' = (/= 0) result + touchManagedPtr ref + return result' + +#if ENABLE_OVERLOADING +data RefIsTagMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.MethodInfo RefIsTagMethodInfo a signature where + overloadedMethod _ = refIsTag + +#endif + +-- method Ref::lookup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Object"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_lookup" ggit_ref_lookup :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Object.Object) + +{- | +Convenient method to resolve a reference to an object. +-} +refLookup :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe Ggit.Object.Object) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Object.Object' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +refLookup ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + onException (do + result <- propagateGError $ ggit_ref_lookup ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Object.Object) result' + return result'' + touchManagedPtr ref + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RefLookupMethodInfo +instance (signature ~ (m (Maybe Ggit.Object.Object)), MonadIO m, IsRef a) => O.MethodInfo RefLookupMethodInfo a signature where + overloadedMethod _ = refLookup + +#endif + +-- method Ref::rename +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "force", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to force the renaming.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "log_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The one line long message to be appended to the reflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_rename" ggit_ref_rename :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + CString -> -- new_name : TBasicType TUTF8 + CInt -> -- force : TBasicType TBoolean + CString -> -- log_message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ref) + +{- | +Rename an existing reference. + +This method works for both direct and symbolic references. + +The new name will be checked for validity. +See @ggit_ref_create_symbolic()@ for rules about valid names. + +If not error, /@ref@/ will be deleted from disk and a +new 'GI.Ggit.Objects.Ref.Ref' will be returned. + +The reference will be immediately renamed in-memory and on disk. + +If the @force@ flag is not enabled, and there\'s already +a reference with the given name, the renaming will fail. + +IMPORTANT: +The user needs to write a proper reflog entry if the +reflog is enabled for the repository. We only rename +the reflog if it exists. +-} +refRename :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> T.Text + {- ^ /@newName@/: the new name. -} + -> Bool + {- ^ /@force@/: 'True' to force the renaming. -} + -> T.Text + {- ^ /@logMessage@/: The one line long message to be appended to the reflog. -} + -> m (Maybe Ref) + {- ^ __Returns:__ a newly created 'GI.Ggit.Objects.Ref.Ref' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +refRename ref newName force logMessage = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + newName' <- textToCString newName + let force' = (fromIntegral . fromEnum) force + logMessage' <- textToCString logMessage + onException (do + result <- propagateGError $ ggit_ref_rename ref' newName' force' logMessage' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ref) result' + return result'' + touchManagedPtr ref + freeMem newName' + freeMem logMessage' + return maybeResult + ) (do + freeMem newName' + freeMem logMessage' + ) + +#if ENABLE_OVERLOADING +data RefRenameMethodInfo +instance (signature ~ (T.Text -> Bool -> T.Text -> m (Maybe Ref)), MonadIO m, IsRef a) => O.MethodInfo RefRenameMethodInfo a signature where + overloadedMethod _ = refRename + +#endif + +-- method Ref::resolve +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_resolve" ggit_ref_resolve :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ref) + +{- | +Resolves a symbolic reference. + +This method iteratively peels a symbolic reference +until it resolves to a direct reference to an OID. + +If a direct reference is passed as an argument, +that reference is returned immediately. +-} +refResolve :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe Ref) + {- ^ __Returns:__ the resolved reference to the peeled one or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +refResolve ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + onException (do + result <- propagateGError $ ggit_ref_resolve ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ref) result' + return result'' + touchManagedPtr ref + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RefResolveMethodInfo +instance (signature ~ (m (Maybe Ref)), MonadIO m, IsRef a) => O.MethodInfo RefResolveMethodInfo a signature where + overloadedMethod _ = refResolve + +#endif + +-- method Ref::set_symbolic_target +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new target for the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "log_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The one line long message to be appended to the reflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_set_symbolic_target" ggit_ref_set_symbolic_target :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + CString -> -- target : TBasicType TUTF8 + CString -> -- log_message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ref) + +{- | +Create a new reference with the same name as the given reference but a +different symbolic target. The reference must be a symbolic reference, +otherwise this will fail. + +The new reference will be written to disk, overwriting the given reference. + +The target name will be checked for validity. +See @ggit_ref_create_symbolic()@ for rules about valid names. +-} +refSetSymbolicTarget :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> T.Text + {- ^ /@target@/: The new target for the reference. -} + -> T.Text + {- ^ /@logMessage@/: The one line long message to be appended to the reflog. -} + -> m (Maybe Ref) + {- ^ __Returns:__ the newly created 'GI.Ggit.Objects.Ref.Ref' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +refSetSymbolicTarget ref target logMessage = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + target' <- textToCString target + logMessage' <- textToCString logMessage + onException (do + result <- propagateGError $ ggit_ref_set_symbolic_target ref' target' logMessage' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ref) result' + return result'' + touchManagedPtr ref + freeMem target' + freeMem logMessage' + return maybeResult + ) (do + freeMem target' + freeMem logMessage' + ) + +#if ENABLE_OVERLOADING +data RefSetSymbolicTargetMethodInfo +instance (signature ~ (T.Text -> T.Text -> m (Maybe Ref)), MonadIO m, IsRef a) => O.MethodInfo RefSetSymbolicTargetMethodInfo a signature where + overloadedMethod _ = refSetSymbolicTarget + +#endif + +-- method Ref::set_target +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "log_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The one line long message to be appended to the reflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_ref_set_target" ggit_ref_set_target :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + CString -> -- log_message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ref) + +{- | +Create a new reference with the same name as the given reference but a +different OID target. The reference must be a direct reference, otherwise +this will fail. + +The new reference will be written to disk, overwriting the given reference. +-} +refSetTarget :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> T.Text + {- ^ /@logMessage@/: The one line long message to be appended to the reflog. -} + -> m (Maybe Ref) + {- ^ __Returns:__ the newly created 'GI.Ggit.Objects.Ref.Ref' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +refSetTarget ref oid logMessage = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + oid' <- unsafeManagedPtrGetPtr oid + logMessage' <- textToCString logMessage + onException (do + result <- propagateGError $ ggit_ref_set_target ref' oid' logMessage' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ref) result' + return result'' + touchManagedPtr ref + touchManagedPtr oid + freeMem logMessage' + return maybeResult + ) (do + freeMem logMessage' + ) + +#if ENABLE_OVERLOADING +data RefSetTargetMethodInfo +instance (signature ~ (Ggit.OId.OId -> T.Text -> m (Maybe Ref)), MonadIO m, IsRef a) => O.MethodInfo RefSetTargetMethodInfo a signature where + overloadedMethod _ = refSetTarget + +#endif + +-- method Ref::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ref", argType = TInterface (Name {namespace = "Ggit", name = "Ref"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_to_string" ggit_ref_to_string :: + Ptr Ref -> -- ref : TInterface (Name {namespace = "Ggit", name = "Ref"}) + IO CString + +{- | +Get a string representation of the ref. +-} +refToString :: + (B.CallStack.HasCallStack, MonadIO m, IsRef a) => + a + {- ^ /@ref@/: a 'GI.Ggit.Objects.Ref.Ref'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ a string representation of the ref or 'Nothing'. -} +refToString ref = liftIO $ do + ref' <- unsafeManagedPtrCastPtr ref + result <- ggit_ref_to_string ref' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr ref + return maybeResult + +#if ENABLE_OVERLOADING +data RefToStringMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.MethodInfo RefToStringMethodInfo a signature where + overloadedMethod _ = refToString + +#endif + +-- method Ref::is_valid_name +-- method type : MemberFunction +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name to validate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_is_valid_name" ggit_ref_is_valid_name :: + CString -> -- name : TBasicType TUTF8 + IO CInt + +{- | +Check if the given /@name@/ is a valid name for a reference. Note that /@name@/ +should be the full ref name (including prefixes). + +Valid toplevel names can contain only capital letters and underscores +and must start and end with a letter (e.g. HEAD, ORIG_HEAD). + +Valid refs\/ names may contain any characters, except \'~\', \'^\', \':\', \'\\\', \'?\', +\'[\', \'*\', \"..\" and \"\@{\", because they are interpreted by revparse. +-} +refIsValidName :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@name@/: the name to validate. -} + -> m Bool + {- ^ __Returns:__ 'True' if /@name@/ is valid, 'False' otherwise. -} +refIsValidName name = liftIO $ do + name' <- textToCString name + result <- ggit_ref_is_valid_name name' + let result' = (/= 0) result + freeMem name' + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/Ggit/Objects/Ref.hs-boot b/GI/Ggit/Objects/Ref.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Ref.hs-boot @@ -0,0 +1,89 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Ref 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 + +newtype Ref = Ref (ManagedPtr Ref) +instance GObject Ref where +class (GObject o, O.IsDescendantOf Ref o) => IsRef o +instance (GObject o, O.IsDescendantOf Ref o) => IsRef o +instance O.HasParentTypes Ref +#if ENABLE_OVERLOADING +data RefDeleteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefDeleteLogMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefGetLogMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefGetOwnerMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefGetReferenceTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefGetShorthandMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefGetSymbolicTargetMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefGetTargetMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefHasLogMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefIsBranchMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefIsNoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefIsRemoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefIsTagMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefLookupMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefRenameMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefResolveMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefSetSymbolicTargetMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefSetTargetMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefToStringMethodInfo +#endif diff --git a/GI/Ggit/Objects/Remote.hs b/GI/Ggit/Objects/Remote.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Remote.hs @@ -0,0 +1,839 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git remote. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Remote + ( + +-- * Exported types + Remote(..) , + IsRemote , + toRemote , + noRemote , + + + -- * Methods +-- ** connect #method:connect# + +#if ENABLE_OVERLOADING + RemoteConnectMethodInfo , +#endif + remoteConnect , + + +-- ** disconnect #method:disconnect# + +#if ENABLE_OVERLOADING + RemoteDisconnectMethodInfo , +#endif + remoteDisconnect , + + +-- ** download #method:download# + +#if ENABLE_OVERLOADING + RemoteDownloadMethodInfo , +#endif + remoteDownload , + + +-- ** getConnected #method:getConnected# + +#if ENABLE_OVERLOADING + RemoteGetConnectedMethodInfo , +#endif + remoteGetConnected , + + +-- ** getFetchSpecs #method:getFetchSpecs# + +#if ENABLE_OVERLOADING + RemoteGetFetchSpecsMethodInfo , +#endif + remoteGetFetchSpecs , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + RemoteGetNameMethodInfo , +#endif + remoteGetName , + + +-- ** getOwner #method:getOwner# + +#if ENABLE_OVERLOADING + RemoteGetOwnerMethodInfo , +#endif + remoteGetOwner , + + +-- ** getPushSpecs #method:getPushSpecs# + +#if ENABLE_OVERLOADING + RemoteGetPushSpecsMethodInfo , +#endif + remoteGetPushSpecs , + + +-- ** getUrl #method:getUrl# + +#if ENABLE_OVERLOADING + RemoteGetUrlMethodInfo , +#endif + remoteGetUrl , + + +-- ** list #method:list# + +#if ENABLE_OVERLOADING + RemoteListMethodInfo , +#endif + remoteList , + + +-- ** new #method:new# + + remoteNew , + + +-- ** newAnonymous #method:newAnonymous# + + remoteNewAnonymous , + + +-- ** updateTips #method:updateTips# + +#if ENABLE_OVERLOADING + RemoteUpdateTipsMethodInfo , +#endif + remoteUpdateTips , + + + + + ) 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.Enums as Ggit.Enums +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.Objects.ProxyOptions as Ggit.ProxyOptions +import {-# SOURCE #-} qualified GI.Ggit.Objects.RemoteCallbacks as Ggit.RemoteCallbacks +import {-# SOURCE #-} qualified GI.Ggit.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Structs.FetchOptions as Ggit.FetchOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.RemoteHead as Ggit.RemoteHead + +-- | Memory-managed wrapper type. +newtype Remote = Remote (ManagedPtr Remote) +foreign import ccall "ggit_remote_get_type" + c_ggit_remote_get_type :: IO GType + +instance GObject Remote where + gobjectType = c_ggit_remote_get_type + + +-- | Type class for types which can be safely cast to `Remote`, for instance with `toRemote`. +class (GObject o, O.IsDescendantOf Remote o) => IsRemote o +instance (GObject o, O.IsDescendantOf Remote o) => IsRemote o + +instance O.HasParentTypes Remote +type instance O.ParentTypes Remote = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Remote`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRemote :: (MonadIO m, IsRemote o) => o -> m Remote +toRemote = liftIO . unsafeCastTo Remote + +-- | A convenience alias for `Nothing` :: `Maybe` `Remote`. +noRemote :: Maybe Remote +noRemote = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRemoteMethod (t :: Symbol) (o :: *) :: * where + ResolveRemoteMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRemoteMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRemoteMethod "connect" o = RemoteConnectMethodInfo + ResolveRemoteMethod "disconnect" o = RemoteDisconnectMethodInfo + ResolveRemoteMethod "download" o = RemoteDownloadMethodInfo + ResolveRemoteMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRemoteMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRemoteMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRemoteMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRemoteMethod "list" o = RemoteListMethodInfo + ResolveRemoteMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRemoteMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRemoteMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRemoteMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRemoteMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRemoteMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRemoteMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRemoteMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRemoteMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRemoteMethod "updateTips" o = RemoteUpdateTipsMethodInfo + ResolveRemoteMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRemoteMethod "getConnected" o = RemoteGetConnectedMethodInfo + ResolveRemoteMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRemoteMethod "getFetchSpecs" o = RemoteGetFetchSpecsMethodInfo + ResolveRemoteMethod "getName" o = RemoteGetNameMethodInfo + ResolveRemoteMethod "getOwner" o = RemoteGetOwnerMethodInfo + ResolveRemoteMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRemoteMethod "getPushSpecs" o = RemoteGetPushSpecsMethodInfo + ResolveRemoteMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRemoteMethod "getUrl" o = RemoteGetUrlMethodInfo + ResolveRemoteMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRemoteMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRemoteMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRemoteMethod t Remote, O.MethodInfo info Remote p) => OL.IsLabel t (Remote -> 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 Remote +type instance O.AttributeList Remote = RemoteAttributeList +type RemoteAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Remote = RemoteSignalList +type RemoteSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Remote::new +-- method type : Constructor +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the remote's name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the remote repository's URL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Remote"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_new" ggit_remote_new :: + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- url : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Remote) + +{- | +Creates a remote with the default refspecs in memory. You can use +this when you have a URL instead of a remote\'s name. +-} +remoteNew :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the remote\'s name. -} + -> T.Text + {- ^ /@url@/: the remote repository\'s URL. -} + -> m (Maybe Remote) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Remote.Remote' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteNew repository name url = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + url' <- textToCString url + onException (do + result <- propagateGError $ ggit_remote_new repository' name' url' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Remote) result' + return result'' + touchManagedPtr repository + freeMem name' + freeMem url' + return maybeResult + ) (do + freeMem name' + freeMem url' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Remote::new_anonymous +-- method type : Constructor +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the remote repository's URL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Remote"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_new_anonymous" ggit_remote_new_anonymous :: + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- url : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Remote) + +{- | +Creates a remote with the specified refspec in memory. You can use +this when you have a URL instead of a remote\'s name. +-} +remoteNewAnonymous :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@url@/: the remote repository\'s URL. -} + -> m (Maybe Remote) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Remote.Remote' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteNewAnonymous repository url = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + url' <- textToCString url + onException (do + result <- propagateGError $ ggit_remote_new_anonymous repository' url' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Remote) result' + return result'' + touchManagedPtr repository + freeMem url' + return maybeResult + ) (do + freeMem url' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Remote::connect +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface (Name {namespace = "Ggit", name = "Direction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether you want to receive or send data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callbacks", argType = TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the callbacks to use for this connection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_options", argType = TInterface (Name {namespace = "Ggit", name = "ProxyOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the proxy options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "custom_headers", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "extra HTTP headers to use in this connection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_connect" ggit_remote_connect :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + CUInt -> -- direction : TInterface (Name {namespace = "Ggit", name = "Direction"}) + Ptr Ggit.RemoteCallbacks.RemoteCallbacks -> -- callbacks : TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"}) + Ptr Ggit.ProxyOptions.ProxyOptions -> -- proxy_options : TInterface (Name {namespace = "Ggit", name = "ProxyOptions"}) + CString -> -- custom_headers : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Opens a connection to a remote. +The transport is selected based on the URL. The direction argument +is due to a limitation of the git protocol (over TCP or SSH) which +starts up a specific binary which can only do the one or the other. +-} +remoteConnect :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a, Ggit.RemoteCallbacks.IsRemoteCallbacks b, Ggit.ProxyOptions.IsProxyOptions c) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> Ggit.Enums.Direction + {- ^ /@direction@/: whether you want to receive or send data. -} + -> b + {- ^ /@callbacks@/: the callbacks to use for this connection. -} + -> Maybe (c) + {- ^ /@proxyOptions@/: the proxy options. -} + -> Maybe (T.Text) + {- ^ /@customHeaders@/: extra HTTP headers to use in this connection. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteConnect remote direction callbacks proxyOptions customHeaders = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + let direction' = (fromIntegral . fromEnum) direction + callbacks' <- unsafeManagedPtrCastPtr callbacks + maybeProxyOptions <- case proxyOptions of + Nothing -> return nullPtr + Just jProxyOptions -> do + jProxyOptions' <- unsafeManagedPtrCastPtr jProxyOptions + return jProxyOptions' + maybeCustomHeaders <- case customHeaders of + Nothing -> return nullPtr + Just jCustomHeaders -> do + jCustomHeaders' <- textToCString jCustomHeaders + return jCustomHeaders' + onException (do + propagateGError $ ggit_remote_connect remote' direction' callbacks' maybeProxyOptions maybeCustomHeaders + touchManagedPtr remote + touchManagedPtr callbacks + whenJust proxyOptions touchManagedPtr + freeMem maybeCustomHeaders + return () + ) (do + freeMem maybeCustomHeaders + ) + +#if ENABLE_OVERLOADING +data RemoteConnectMethodInfo +instance (signature ~ (Ggit.Enums.Direction -> b -> Maybe (c) -> Maybe (T.Text) -> m ()), MonadIO m, IsRemote a, Ggit.RemoteCallbacks.IsRemoteCallbacks b, Ggit.ProxyOptions.IsProxyOptions c) => O.MethodInfo RemoteConnectMethodInfo a signature where + overloadedMethod _ = remoteConnect + +#endif + +-- method Remote::disconnect +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_disconnect" ggit_remote_disconnect :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + IO () + +{- | +Closes the connection to the remote and frees the underlying +transport. +-} +remoteDisconnect :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> m () +remoteDisconnect remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + ggit_remote_disconnect remote' + touchManagedPtr remote + return () + +#if ENABLE_OVERLOADING +data RemoteDisconnectMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRemote a) => O.MethodInfo RemoteDisconnectMethodInfo a signature where + overloadedMethod _ = remoteDisconnect + +#endif + +-- method Remote::download +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "specs", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the ref specs.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fetch_options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_download" ggit_remote_download :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + Ptr CString -> -- specs : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr Ggit.FetchOptions.FetchOptions -> -- fetch_options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Connect to the remote if not yet connected, negotiate with the remote +about which objects are missing and download the resulting packfile and +its index. +-} +remoteDownload :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> Maybe ([T.Text]) + {- ^ /@specs@/: the ref specs. -} + -> Ggit.FetchOptions.FetchOptions + {- ^ /@fetchOptions@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteDownload remote specs fetchOptions = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + maybeSpecs <- case specs of + Nothing -> return nullPtr + Just jSpecs -> do + jSpecs' <- packZeroTerminatedUTF8CArray jSpecs + return jSpecs' + fetchOptions' <- unsafeManagedPtrGetPtr fetchOptions + onException (do + _ <- propagateGError $ ggit_remote_download remote' maybeSpecs fetchOptions' + touchManagedPtr remote + touchManagedPtr fetchOptions + mapZeroTerminatedCArray freeMem maybeSpecs + freeMem maybeSpecs + return () + ) (do + mapZeroTerminatedCArray freeMem maybeSpecs + freeMem maybeSpecs + ) + +#if ENABLE_OVERLOADING +data RemoteDownloadMethodInfo +instance (signature ~ (Maybe ([T.Text]) -> Ggit.FetchOptions.FetchOptions -> m ()), MonadIO m, IsRemote a) => O.MethodInfo RemoteDownloadMethodInfo a signature where + overloadedMethod _ = remoteDownload + +#endif + +-- method Remote::get_connected +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_get_connected" ggit_remote_get_connected :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + IO CInt + +{- | +Check whether /@remote@/ is connected. +-} +remoteGetConnected :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> m Bool + {- ^ __Returns:__ 'True' if it is connected. -} +remoteGetConnected remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + result <- ggit_remote_get_connected remote' + let result' = (/= 0) result + touchManagedPtr remote + return result' + +#if ENABLE_OVERLOADING +data RemoteGetConnectedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRemote a) => O.MethodInfo RemoteGetConnectedMethodInfo a signature where + overloadedMethod _ = remoteGetConnected + +#endif + +-- method Remote::get_fetch_specs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_get_fetch_specs" ggit_remote_get_fetch_specs :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + Ptr (Ptr GError) -> -- error + IO (Ptr CString) + +{- | +Get the list of fetch refspecs for the given remote. +-} +remoteGetFetchSpecs :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a list of fetch refspecs or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteGetFetchSpecs remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + onException (do + result <- propagateGError $ ggit_remote_get_fetch_specs remote' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr remote + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RemoteGetFetchSpecsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsRemote a) => O.MethodInfo RemoteGetFetchSpecsMethodInfo a signature where + overloadedMethod _ = remoteGetFetchSpecs + +#endif + +-- method Remote::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_get_name" ggit_remote_get_name :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + IO CString + +{- | +Gets the remote\'s name. +-} +remoteGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of /@remote@/ or 'Nothing'. -} +remoteGetName remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + result <- ggit_remote_get_name remote' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr remote + return maybeResult + +#if ENABLE_OVERLOADING +data RemoteGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRemote a) => O.MethodInfo RemoteGetNameMethodInfo a signature where + overloadedMethod _ = remoteGetName + +#endif + +-- method Remote::get_owner +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_get_owner" ggit_remote_get_owner :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + IO (Ptr Ggit.Repository.Repository) + +{- | +Gets the repository where /@remote@/ resides. +-} +remoteGetOwner :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> m (Maybe Ggit.Repository.Repository) + {- ^ __Returns:__ the repository where the remote resides or 'Nothing'. -} +remoteGetOwner remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + result <- ggit_remote_get_owner remote' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Repository.Repository) result' + return result'' + touchManagedPtr remote + return maybeResult + +#if ENABLE_OVERLOADING +data RemoteGetOwnerMethodInfo +instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsRemote a) => O.MethodInfo RemoteGetOwnerMethodInfo a signature where + overloadedMethod _ = remoteGetOwner + +#endif + +-- method Remote::get_push_specs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_get_push_specs" ggit_remote_get_push_specs :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + Ptr (Ptr GError) -> -- error + IO (Ptr CString) + +{- | +Get the list of push refspecs for the given remote. +-} +remoteGetPushSpecs :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a list of push refspecs or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteGetPushSpecs remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + onException (do + result <- propagateGError $ ggit_remote_get_push_specs remote' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr remote + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RemoteGetPushSpecsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsRemote a) => O.MethodInfo RemoteGetPushSpecsMethodInfo a signature where + overloadedMethod _ = remoteGetPushSpecs + +#endif + +-- method Remote::get_url +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_get_url" ggit_remote_get_url :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + IO CString + +{- | +Gets the remote\'s url. +-} +remoteGetUrl :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: GgitRemote. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the url of /@remote@/ or 'Nothing'. -} +remoteGetUrl remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + result <- ggit_remote_get_url remote' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr remote + return maybeResult + +#if ENABLE_OVERLOADING +data RemoteGetUrlMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRemote a) => O.MethodInfo RemoteGetUrlMethodInfo a signature where + overloadedMethod _ = remoteGetUrl + +#endif + +-- method Remote::list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TInterface (Name {namespace = "Ggit", name = "RemoteHead"}))) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_list" ggit_remote_list :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + Ptr (Ptr GError) -> -- error + IO (Ptr (Ptr Ggit.RemoteHead.RemoteHead)) + +{- | +Get a list of refs at the remote. +-} +remoteList :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> m (Maybe [Ggit.RemoteHead.RemoteHead]) + {- ^ __Returns:__ the remote heads or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteList remote = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + onException (do + result <- propagateGError $ ggit_remote_list remote' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedPtrArray result' + result''' <- mapM (wrapBoxed Ggit.RemoteHead.RemoteHead) result'' + freeMem result' + return result''' + touchManagedPtr remote + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RemoteListMethodInfo +instance (signature ~ (m (Maybe [Ggit.RemoteHead.RemoteHead])), MonadIO m, IsRemote a) => O.MethodInfo RemoteListMethodInfo a signature where + overloadedMethod _ = remoteList + +#endif + +-- method Remote::update_tips +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callbacks", argType = TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemoteCallbacks.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update_fetch_head", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to write to FETCH_HEAD. %TRUE to behave like git.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags_type", argType = TInterface (Name {namespace = "Ggit", name = "RemoteDownloadTagsType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "what the behaviour for downloading tags is for this fetch. This is\n ignored for push. This must be the same value passed to\n ggit_remote_download().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "reflog_message The message to insert into the reflogs. If\n %NULL and fetching, the default is \"fetch \",\n where is the name of the remote (or its url,\n for in-memory remotes). This parameter is ignored when pushing.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_remote_update_tips" ggit_remote_update_tips :: + Ptr Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + Ptr Ggit.RemoteCallbacks.RemoteCallbacks -> -- callbacks : TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"}) + CInt -> -- update_fetch_head : TBasicType TBoolean + CUInt -> -- tags_type : TInterface (Name {namespace = "Ggit", name = "RemoteDownloadTagsType"}) + CString -> -- message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Update tips to the new state. +-} +remoteUpdateTips :: + (B.CallStack.HasCallStack, MonadIO m, IsRemote a, Ggit.RemoteCallbacks.IsRemoteCallbacks b) => + a + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> b + {- ^ /@callbacks@/: a 'GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks'. -} + -> Bool + {- ^ /@updateFetchHead@/: whether to write to FETCH_HEAD. 'True' to behave like git. -} + -> Ggit.Enums.RemoteDownloadTagsType + {- ^ /@tagsType@/: what the behaviour for downloading tags is for this fetch. This is + ignored for push. This must be the same value passed to + 'GI.Ggit.Objects.Remote.remoteDownload'. -} + -> Maybe (T.Text) + {- ^ /@message@/: reflog_message The message to insert into the reflogs. If + 'Nothing' and fetching, the default is \"fetch \\", + where \ is the name of the remote (or its url, + for in-memory remotes). This parameter is ignored when pushing. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +remoteUpdateTips remote callbacks updateFetchHead tagsType message = liftIO $ do + remote' <- unsafeManagedPtrCastPtr remote + callbacks' <- unsafeManagedPtrCastPtr callbacks + let updateFetchHead' = (fromIntegral . fromEnum) updateFetchHead + let tagsType' = (fromIntegral . fromEnum) tagsType + maybeMessage <- case message of + Nothing -> return nullPtr + Just jMessage -> do + jMessage' <- textToCString jMessage + return jMessage' + onException (do + _ <- propagateGError $ ggit_remote_update_tips remote' callbacks' updateFetchHead' tagsType' maybeMessage + touchManagedPtr remote + touchManagedPtr callbacks + freeMem maybeMessage + return () + ) (do + freeMem maybeMessage + ) + +#if ENABLE_OVERLOADING +data RemoteUpdateTipsMethodInfo +instance (signature ~ (b -> Bool -> Ggit.Enums.RemoteDownloadTagsType -> Maybe (T.Text) -> m ()), MonadIO m, IsRemote a, Ggit.RemoteCallbacks.IsRemoteCallbacks b) => O.MethodInfo RemoteUpdateTipsMethodInfo a signature where + overloadedMethod _ = remoteUpdateTips + +#endif + + diff --git a/GI/Ggit/Objects/Remote.hs-boot b/GI/Ggit/Objects/Remote.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Remote.hs-boot @@ -0,0 +1,62 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Remote 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 + +newtype Remote = Remote (ManagedPtr Remote) +instance GObject Remote where +class (GObject o, O.IsDescendantOf Remote o) => IsRemote o +instance (GObject o, O.IsDescendantOf Remote o) => IsRemote o +instance O.HasParentTypes Remote +#if ENABLE_OVERLOADING +data RemoteConnectMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteDisconnectMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteDownloadMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteGetConnectedMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteGetFetchSpecsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteGetOwnerMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteGetPushSpecsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteGetUrlMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteListMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteUpdateTipsMethodInfo +#endif diff --git a/GI/Ggit/Objects/RemoteCallbacks.hs b/GI/Ggit/Objects/RemoteCallbacks.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/RemoteCallbacks.hs @@ -0,0 +1,497 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git remote callbacks. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.RemoteCallbacks + ( + +-- * Exported types + RemoteCallbacks(..) , + IsRemoteCallbacks , + toRemoteCallbacks , + noRemoteCallbacks , + + + -- * Signals +-- ** completion #signal:completion# + + C_RemoteCallbacksCompletionCallback , + RemoteCallbacksCompletionCallback , +#if ENABLE_OVERLOADING + RemoteCallbacksCompletionSignalInfo , +#endif + afterRemoteCallbacksCompletion , + genClosure_RemoteCallbacksCompletion , + mk_RemoteCallbacksCompletionCallback , + noRemoteCallbacksCompletionCallback , + onRemoteCallbacksCompletion , + wrap_RemoteCallbacksCompletionCallback , + + +-- ** progress #signal:progress# + + C_RemoteCallbacksProgressCallback , + RemoteCallbacksProgressCallback , +#if ENABLE_OVERLOADING + RemoteCallbacksProgressSignalInfo , +#endif + afterRemoteCallbacksProgress , + genClosure_RemoteCallbacksProgress , + mk_RemoteCallbacksProgressCallback , + noRemoteCallbacksProgressCallback , + onRemoteCallbacksProgress , + wrap_RemoteCallbacksProgressCallback , + + +-- ** transferProgress #signal:transferProgress# + + C_RemoteCallbacksTransferProgressCallback, + RemoteCallbacksTransferProgressCallback , +#if ENABLE_OVERLOADING + RemoteCallbacksTransferProgressSignalInfo, +#endif + afterRemoteCallbacksTransferProgress , + genClosure_RemoteCallbacksTransferProgress, + mk_RemoteCallbacksTransferProgressCallback, + noRemoteCallbacksTransferProgressCallback, + onRemoteCallbacksTransferProgress , + wrap_RemoteCallbacksTransferProgressCallback, + + +-- ** updateTips #signal:updateTips# + + C_RemoteCallbacksUpdateTipsCallback , + RemoteCallbacksUpdateTipsCallback , +#if ENABLE_OVERLOADING + RemoteCallbacksUpdateTipsSignalInfo , +#endif + afterRemoteCallbacksUpdateTips , + genClosure_RemoteCallbacksUpdateTips , + mk_RemoteCallbacksUpdateTipsCallback , + noRemoteCallbacksUpdateTipsCallback , + onRemoteCallbacksUpdateTips , + wrap_RemoteCallbacksUpdateTipsCallback , + + + + + ) 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.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.TransferProgress as Ggit.TransferProgress + +-- | Memory-managed wrapper type. +newtype RemoteCallbacks = RemoteCallbacks (ManagedPtr RemoteCallbacks) +foreign import ccall "ggit_remote_callbacks_get_type" + c_ggit_remote_callbacks_get_type :: IO GType + +instance GObject RemoteCallbacks where + gobjectType = c_ggit_remote_callbacks_get_type + + +-- | Type class for types which can be safely cast to `RemoteCallbacks`, for instance with `toRemoteCallbacks`. +class (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o +instance (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o + +instance O.HasParentTypes RemoteCallbacks +type instance O.ParentTypes RemoteCallbacks = '[GObject.Object.Object] + +-- | Cast to `RemoteCallbacks`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRemoteCallbacks :: (MonadIO m, IsRemoteCallbacks o) => o -> m RemoteCallbacks +toRemoteCallbacks = liftIO . unsafeCastTo RemoteCallbacks + +-- | A convenience alias for `Nothing` :: `Maybe` `RemoteCallbacks`. +noRemoteCallbacks :: Maybe RemoteCallbacks +noRemoteCallbacks = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRemoteCallbacksMethod (t :: Symbol) (o :: *) :: * where + ResolveRemoteCallbacksMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRemoteCallbacksMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRemoteCallbacksMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRemoteCallbacksMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRemoteCallbacksMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRemoteCallbacksMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRemoteCallbacksMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRemoteCallbacksMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRemoteCallbacksMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRemoteCallbacksMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRemoteCallbacksMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRemoteCallbacksMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRemoteCallbacksMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRemoteCallbacksMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRemoteCallbacksMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRemoteCallbacksMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRemoteCallbacksMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRemoteCallbacksMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRemoteCallbacksMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRemoteCallbacksMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRemoteCallbacksMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRemoteCallbacksMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRemoteCallbacksMethod t RemoteCallbacks, O.MethodInfo info RemoteCallbacks p) => OL.IsLabel t (RemoteCallbacks -> 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 + +-- signal RemoteCallbacks::completion +{- | +/No description available in the introspection data./ +-} +type RemoteCallbacksCompletionCallback = + Ggit.Enums.RemoteCompletionType + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksCompletionCallback`@. +noRemoteCallbacksCompletionCallback :: Maybe RemoteCallbacksCompletionCallback +noRemoteCallbacksCompletionCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_RemoteCallbacksCompletionCallback = + Ptr () -> -- object + CUInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksCompletionCallback`. +foreign import ccall "wrapper" + mk_RemoteCallbacksCompletionCallback :: C_RemoteCallbacksCompletionCallback -> IO (FunPtr C_RemoteCallbacksCompletionCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_RemoteCallbacksCompletion :: MonadIO m => RemoteCallbacksCompletionCallback -> m (GClosure C_RemoteCallbacksCompletionCallback) +genClosure_RemoteCallbacksCompletion cb = liftIO $ do + let cb' = wrap_RemoteCallbacksCompletionCallback cb + mk_RemoteCallbacksCompletionCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `RemoteCallbacksCompletionCallback` into a `C_RemoteCallbacksCompletionCallback`. +wrap_RemoteCallbacksCompletionCallback :: + RemoteCallbacksCompletionCallback -> + C_RemoteCallbacksCompletionCallback +wrap_RemoteCallbacksCompletionCallback _cb _ object _ = do + let object' = (toEnum . fromIntegral) object + _cb object' + + +{- | +Connect a signal handler for the “@completion@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' remoteCallbacks #completion callback +@ +-} +onRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId +onRemoteCallbacksCompletion obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksCompletionCallback cb + cb'' <- mk_RemoteCallbacksCompletionCallback cb' + connectSignalFunPtr obj "completion" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@completion@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' remoteCallbacks #completion callback +@ +-} +afterRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId +afterRemoteCallbacksCompletion obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksCompletionCallback cb + cb'' <- mk_RemoteCallbacksCompletionCallback cb' + connectSignalFunPtr obj "completion" cb'' SignalConnectAfter + + +-- signal RemoteCallbacks::progress +{- | +/No description available in the introspection data./ +-} +type RemoteCallbacksProgressCallback = + T.Text + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksProgressCallback`@. +noRemoteCallbacksProgressCallback :: Maybe RemoteCallbacksProgressCallback +noRemoteCallbacksProgressCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_RemoteCallbacksProgressCallback = + Ptr () -> -- object + CString -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksProgressCallback`. +foreign import ccall "wrapper" + mk_RemoteCallbacksProgressCallback :: C_RemoteCallbacksProgressCallback -> IO (FunPtr C_RemoteCallbacksProgressCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_RemoteCallbacksProgress :: MonadIO m => RemoteCallbacksProgressCallback -> m (GClosure C_RemoteCallbacksProgressCallback) +genClosure_RemoteCallbacksProgress cb = liftIO $ do + let cb' = wrap_RemoteCallbacksProgressCallback cb + mk_RemoteCallbacksProgressCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `RemoteCallbacksProgressCallback` into a `C_RemoteCallbacksProgressCallback`. +wrap_RemoteCallbacksProgressCallback :: + RemoteCallbacksProgressCallback -> + C_RemoteCallbacksProgressCallback +wrap_RemoteCallbacksProgressCallback _cb _ object _ = do + object' <- cstringToText object + _cb object' + + +{- | +Connect a signal handler for the “@progress@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' remoteCallbacks #progress callback +@ +-} +onRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId +onRemoteCallbacksProgress obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksProgressCallback cb + cb'' <- mk_RemoteCallbacksProgressCallback cb' + connectSignalFunPtr obj "progress" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@progress@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' remoteCallbacks #progress callback +@ +-} +afterRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId +afterRemoteCallbacksProgress obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksProgressCallback cb + cb'' <- mk_RemoteCallbacksProgressCallback cb' + connectSignalFunPtr obj "progress" cb'' SignalConnectAfter + + +-- signal RemoteCallbacks::transfer-progress +{- | +/No description available in the introspection data./ +-} +type RemoteCallbacksTransferProgressCallback = + Ggit.TransferProgress.TransferProgress + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksTransferProgressCallback`@. +noRemoteCallbacksTransferProgressCallback :: Maybe RemoteCallbacksTransferProgressCallback +noRemoteCallbacksTransferProgressCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_RemoteCallbacksTransferProgressCallback = + Ptr () -> -- object + Ptr Ggit.TransferProgress.TransferProgress -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksTransferProgressCallback`. +foreign import ccall "wrapper" + mk_RemoteCallbacksTransferProgressCallback :: C_RemoteCallbacksTransferProgressCallback -> IO (FunPtr C_RemoteCallbacksTransferProgressCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_RemoteCallbacksTransferProgress :: MonadIO m => RemoteCallbacksTransferProgressCallback -> m (GClosure C_RemoteCallbacksTransferProgressCallback) +genClosure_RemoteCallbacksTransferProgress cb = liftIO $ do + let cb' = wrap_RemoteCallbacksTransferProgressCallback cb + mk_RemoteCallbacksTransferProgressCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `RemoteCallbacksTransferProgressCallback` into a `C_RemoteCallbacksTransferProgressCallback`. +wrap_RemoteCallbacksTransferProgressCallback :: + RemoteCallbacksTransferProgressCallback -> + C_RemoteCallbacksTransferProgressCallback +wrap_RemoteCallbacksTransferProgressCallback _cb _ object _ = do + B.ManagedPtr.withTransient Ggit.TransferProgress.TransferProgress object $ \object' -> do + _cb object' + + +{- | +Connect a signal handler for the “@transfer-progress@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' remoteCallbacks #transferProgress callback +@ +-} +onRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId +onRemoteCallbacksTransferProgress obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksTransferProgressCallback cb + cb'' <- mk_RemoteCallbacksTransferProgressCallback cb' + connectSignalFunPtr obj "transfer-progress" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@transfer-progress@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' remoteCallbacks #transferProgress callback +@ +-} +afterRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId +afterRemoteCallbacksTransferProgress obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksTransferProgressCallback cb + cb'' <- mk_RemoteCallbacksTransferProgressCallback cb' + connectSignalFunPtr obj "transfer-progress" cb'' SignalConnectAfter + + +-- signal RemoteCallbacks::update-tips +{- | +/No description available in the introspection data./ +-} +type RemoteCallbacksUpdateTipsCallback = + T.Text + -> Ggit.OId.OId + -> Ggit.OId.OId + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RemoteCallbacksUpdateTipsCallback`@. +noRemoteCallbacksUpdateTipsCallback :: Maybe RemoteCallbacksUpdateTipsCallback +noRemoteCallbacksUpdateTipsCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_RemoteCallbacksUpdateTipsCallback = + Ptr () -> -- object + CString -> + Ptr Ggit.OId.OId -> + Ptr Ggit.OId.OId -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_RemoteCallbacksUpdateTipsCallback`. +foreign import ccall "wrapper" + mk_RemoteCallbacksUpdateTipsCallback :: C_RemoteCallbacksUpdateTipsCallback -> IO (FunPtr C_RemoteCallbacksUpdateTipsCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_RemoteCallbacksUpdateTips :: MonadIO m => RemoteCallbacksUpdateTipsCallback -> m (GClosure C_RemoteCallbacksUpdateTipsCallback) +genClosure_RemoteCallbacksUpdateTips cb = liftIO $ do + let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb + mk_RemoteCallbacksUpdateTipsCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `RemoteCallbacksUpdateTipsCallback` into a `C_RemoteCallbacksUpdateTipsCallback`. +wrap_RemoteCallbacksUpdateTipsCallback :: + RemoteCallbacksUpdateTipsCallback -> + C_RemoteCallbacksUpdateTipsCallback +wrap_RemoteCallbacksUpdateTipsCallback _cb _ object p0 p1 _ = do + object' <- cstringToText object + B.ManagedPtr.withTransient Ggit.OId.OId p0 $ \p0' -> do + B.ManagedPtr.withTransient Ggit.OId.OId p1 $ \p1' -> do + _cb object' p0' p1' + + +{- | +Connect a signal handler for the “@update-tips@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' remoteCallbacks #updateTips callback +@ +-} +onRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId +onRemoteCallbacksUpdateTips obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb + cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb' + connectSignalFunPtr obj "update-tips" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@update-tips@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' remoteCallbacks #updateTips callback +@ +-} +afterRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId +afterRemoteCallbacksUpdateTips obj cb = liftIO $ do + let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb + cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb' + connectSignalFunPtr obj "update-tips" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RemoteCallbacks +type instance O.AttributeList RemoteCallbacks = RemoteCallbacksAttributeList +type RemoteCallbacksAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data RemoteCallbacksCompletionSignalInfo +instance SignalInfo RemoteCallbacksCompletionSignalInfo where + type HaskellCallbackType RemoteCallbacksCompletionSignalInfo = RemoteCallbacksCompletionCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_RemoteCallbacksCompletionCallback cb + cb'' <- mk_RemoteCallbacksCompletionCallback cb' + connectSignalFunPtr obj "completion" cb'' connectMode + +data RemoteCallbacksProgressSignalInfo +instance SignalInfo RemoteCallbacksProgressSignalInfo where + type HaskellCallbackType RemoteCallbacksProgressSignalInfo = RemoteCallbacksProgressCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_RemoteCallbacksProgressCallback cb + cb'' <- mk_RemoteCallbacksProgressCallback cb' + connectSignalFunPtr obj "progress" cb'' connectMode + +data RemoteCallbacksTransferProgressSignalInfo +instance SignalInfo RemoteCallbacksTransferProgressSignalInfo where + type HaskellCallbackType RemoteCallbacksTransferProgressSignalInfo = RemoteCallbacksTransferProgressCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_RemoteCallbacksTransferProgressCallback cb + cb'' <- mk_RemoteCallbacksTransferProgressCallback cb' + connectSignalFunPtr obj "transfer-progress" cb'' connectMode + +data RemoteCallbacksUpdateTipsSignalInfo +instance SignalInfo RemoteCallbacksUpdateTipsSignalInfo where + type HaskellCallbackType RemoteCallbacksUpdateTipsSignalInfo = RemoteCallbacksUpdateTipsCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb + cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb' + connectSignalFunPtr obj "update-tips" cb'' connectMode + +type instance O.SignalList RemoteCallbacks = RemoteCallbacksSignalList +type RemoteCallbacksSignalList = ('[ '("completion", RemoteCallbacksCompletionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("progress", RemoteCallbacksProgressSignalInfo), '("transferProgress", RemoteCallbacksTransferProgressSignalInfo), '("updateTips", RemoteCallbacksUpdateTipsSignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/Ggit/Objects/RemoteCallbacks.hs-boot b/GI/Ggit/Objects/RemoteCallbacks.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/RemoteCallbacks.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.RemoteCallbacks 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 + +newtype RemoteCallbacks = RemoteCallbacks (ManagedPtr RemoteCallbacks) +instance GObject RemoteCallbacks where +class (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o +instance (GObject o, O.IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o +instance O.HasParentTypes RemoteCallbacks +#if ENABLE_OVERLOADING +data RemoteCallbacksCompletionSignalInfo +#endif +#if ENABLE_OVERLOADING +data RemoteCallbacksProgressSignalInfo +#endif +#if ENABLE_OVERLOADING +data RemoteCallbacksTransferProgressSignalInfo +#endif +#if ENABLE_OVERLOADING +data RemoteCallbacksUpdateTipsSignalInfo +#endif diff --git a/GI/Ggit/Objects/Repository.hs b/GI/Ggit/Objects/Repository.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Repository.hs @@ -0,0 +1,5963 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents an existing git repository including all of it\'s +object contents. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Repository + ( + +-- * Exported types + Repository(..) , + IsRepository , + toRepository , + noRepository , + + + -- * Methods +-- ** addRemoteFetch #method:addRemoteFetch# + +#if ENABLE_OVERLOADING + RepositoryAddRemoteFetchMethodInfo , +#endif + repositoryAddRemoteFetch , + + +-- ** addRemotePush #method:addRemotePush# + +#if ENABLE_OVERLOADING + RepositoryAddRemotePushMethodInfo , +#endif + repositoryAddRemotePush , + + +-- ** blameFile #method:blameFile# + +#if ENABLE_OVERLOADING + RepositoryBlameFileMethodInfo , +#endif + repositoryBlameFile , + + +-- ** checkoutHead #method:checkoutHead# + +#if ENABLE_OVERLOADING + RepositoryCheckoutHeadMethodInfo , +#endif + repositoryCheckoutHead , + + +-- ** checkoutIndex #method:checkoutIndex# + +#if ENABLE_OVERLOADING + RepositoryCheckoutIndexMethodInfo , +#endif + repositoryCheckoutIndex , + + +-- ** checkoutTree #method:checkoutTree# + +#if ENABLE_OVERLOADING + RepositoryCheckoutTreeMethodInfo , +#endif + repositoryCheckoutTree , + + +-- ** cherryPick #method:cherryPick# + +#if ENABLE_OVERLOADING + RepositoryCherryPickMethodInfo , +#endif + repositoryCherryPick , + + +-- ** cherryPickCommit #method:cherryPickCommit# + +#if ENABLE_OVERLOADING + RepositoryCherryPickCommitMethodInfo , +#endif + repositoryCherryPickCommit , + + +-- ** clone #method:clone# + + repositoryClone , + + +-- ** createBlob #method:createBlob# + +#if ENABLE_OVERLOADING + RepositoryCreateBlobMethodInfo , +#endif + repositoryCreateBlob , + + +-- ** createBlobFromBuffer #method:createBlobFromBuffer# + +#if ENABLE_OVERLOADING + RepositoryCreateBlobFromBufferMethodInfo, +#endif + repositoryCreateBlobFromBuffer , + + +-- ** createBlobFromFile #method:createBlobFromFile# + +#if ENABLE_OVERLOADING + RepositoryCreateBlobFromFileMethodInfo , +#endif + repositoryCreateBlobFromFile , + + +-- ** createBlobFromPath #method:createBlobFromPath# + +#if ENABLE_OVERLOADING + RepositoryCreateBlobFromPathMethodInfo , +#endif + repositoryCreateBlobFromPath , + + +-- ** createBranch #method:createBranch# + +#if ENABLE_OVERLOADING + RepositoryCreateBranchMethodInfo , +#endif + repositoryCreateBranch , + + +-- ** createCommit #method:createCommit# + +#if ENABLE_OVERLOADING + RepositoryCreateCommitMethodInfo , +#endif + repositoryCreateCommit , + + +-- ** createCommitFromIds #method:createCommitFromIds# + +#if ENABLE_OVERLOADING + RepositoryCreateCommitFromIdsMethodInfo , +#endif + repositoryCreateCommitFromIds , + + +-- ** createIndexEntryForFile #method:createIndexEntryForFile# + +#if ENABLE_OVERLOADING + RepositoryCreateIndexEntryForFileMethodInfo, +#endif + repositoryCreateIndexEntryForFile , + + +-- ** createIndexEntryForPath #method:createIndexEntryForPath# + +#if ENABLE_OVERLOADING + RepositoryCreateIndexEntryForPathMethodInfo, +#endif + repositoryCreateIndexEntryForPath , + + +-- ** createNote #method:createNote# + +#if ENABLE_OVERLOADING + RepositoryCreateNoteMethodInfo , +#endif + repositoryCreateNote , + + +-- ** createReference #method:createReference# + +#if ENABLE_OVERLOADING + RepositoryCreateReferenceMethodInfo , +#endif + repositoryCreateReference , + + +-- ** createRemote #method:createRemote# + +#if ENABLE_OVERLOADING + RepositoryCreateRemoteMethodInfo , +#endif + repositoryCreateRemote , + + +-- ** createSymbolicReference #method:createSymbolicReference# + +#if ENABLE_OVERLOADING + RepositoryCreateSymbolicReferenceMethodInfo, +#endif + repositoryCreateSymbolicReference , + + +-- ** createTag #method:createTag# + +#if ENABLE_OVERLOADING + RepositoryCreateTagMethodInfo , +#endif + repositoryCreateTag , + + +-- ** createTagAnnotation #method:createTagAnnotation# + +#if ENABLE_OVERLOADING + RepositoryCreateTagAnnotationMethodInfo , +#endif + repositoryCreateTagAnnotation , + + +-- ** createTagFromBuffer #method:createTagFromBuffer# + +#if ENABLE_OVERLOADING + RepositoryCreateTagFromBufferMethodInfo , +#endif + repositoryCreateTagFromBuffer , + + +-- ** createTagLightweight #method:createTagLightweight# + +#if ENABLE_OVERLOADING + RepositoryCreateTagLightweightMethodInfo, +#endif + repositoryCreateTagLightweight , + + +-- ** createTreeBuilder #method:createTreeBuilder# + +#if ENABLE_OVERLOADING + RepositoryCreateTreeBuilderMethodInfo , +#endif + repositoryCreateTreeBuilder , + + +-- ** createTreeBuilderFromTree #method:createTreeBuilderFromTree# + +#if ENABLE_OVERLOADING + RepositoryCreateTreeBuilderFromTreeMethodInfo, +#endif + repositoryCreateTreeBuilderFromTree , + + +-- ** deleteTag #method:deleteTag# + +#if ENABLE_OVERLOADING + RepositoryDeleteTagMethodInfo , +#endif + repositoryDeleteTag , + + +-- ** discover #method:discover# + + repositoryDiscover , + + +-- ** discoverFull #method:discoverFull# + + repositoryDiscoverFull , + + +-- ** dropStash #method:dropStash# + +#if ENABLE_OVERLOADING + RepositoryDropStashMethodInfo , +#endif + repositoryDropStash , + + +-- ** enumerateBranches #method:enumerateBranches# + +#if ENABLE_OVERLOADING + RepositoryEnumerateBranchesMethodInfo , +#endif + repositoryEnumerateBranches , + + +-- ** fileStatus #method:fileStatus# + +#if ENABLE_OVERLOADING + RepositoryFileStatusMethodInfo , +#endif + repositoryFileStatus , + + +-- ** fileStatusForeach #method:fileStatusForeach# + +#if ENABLE_OVERLOADING + RepositoryFileStatusForeachMethodInfo , +#endif + repositoryFileStatusForeach , + + +-- ** getAheadBehind #method:getAheadBehind# + +#if ENABLE_OVERLOADING + RepositoryGetAheadBehindMethodInfo , +#endif + repositoryGetAheadBehind , + + +-- ** getAttribute #method:getAttribute# + +#if ENABLE_OVERLOADING + RepositoryGetAttributeMethodInfo , +#endif + repositoryGetAttribute , + + +-- ** getConfig #method:getConfig# + +#if ENABLE_OVERLOADING + RepositoryGetConfigMethodInfo , +#endif + repositoryGetConfig , + + +-- ** getDefaultNotesRef #method:getDefaultNotesRef# + +#if ENABLE_OVERLOADING + RepositoryGetDefaultNotesRefMethodInfo , +#endif + repositoryGetDefaultNotesRef , + + +-- ** getDescendantOf #method:getDescendantOf# + +#if ENABLE_OVERLOADING + RepositoryGetDescendantOfMethodInfo , +#endif + repositoryGetDescendantOf , + + +-- ** getHead #method:getHead# + +#if ENABLE_OVERLOADING + RepositoryGetHeadMethodInfo , +#endif + repositoryGetHead , + + +-- ** getIndex #method:getIndex# + +#if ENABLE_OVERLOADING + RepositoryGetIndexMethodInfo , +#endif + repositoryGetIndex , + + +-- ** getLocation #method:getLocation# + +#if ENABLE_OVERLOADING + RepositoryGetLocationMethodInfo , +#endif + repositoryGetLocation , + + +-- ** getSubmoduleStatus #method:getSubmoduleStatus# + +#if ENABLE_OVERLOADING + RepositoryGetSubmoduleStatusMethodInfo , +#endif + repositoryGetSubmoduleStatus , + + +-- ** getWorkdir #method:getWorkdir# + +#if ENABLE_OVERLOADING + RepositoryGetWorkdirMethodInfo , +#endif + repositoryGetWorkdir , + + +-- ** initRepository #method:initRepository# + + repositoryInitRepository , + + +-- ** isBare #method:isBare# + +#if ENABLE_OVERLOADING + RepositoryIsBareMethodInfo , +#endif + repositoryIsBare , + + +-- ** isEmpty #method:isEmpty# + +#if ENABLE_OVERLOADING + RepositoryIsEmptyMethodInfo , +#endif + repositoryIsEmpty , + + +-- ** isHeadDetached #method:isHeadDetached# + +#if ENABLE_OVERLOADING + RepositoryIsHeadDetachedMethodInfo , +#endif + repositoryIsHeadDetached , + + +-- ** isHeadUnborn #method:isHeadUnborn# + +#if ENABLE_OVERLOADING + RepositoryIsHeadUnbornMethodInfo , +#endif + repositoryIsHeadUnborn , + + +-- ** listRemotes #method:listRemotes# + +#if ENABLE_OVERLOADING + RepositoryListRemotesMethodInfo , +#endif + repositoryListRemotes , + + +-- ** listTags #method:listTags# + +#if ENABLE_OVERLOADING + RepositoryListTagsMethodInfo , +#endif + repositoryListTags , + + +-- ** listTagsMatch #method:listTagsMatch# + +#if ENABLE_OVERLOADING + RepositoryListTagsMatchMethodInfo , +#endif + repositoryListTagsMatch , + + +-- ** lookup #method:lookup# + +#if ENABLE_OVERLOADING + RepositoryLookupMethodInfo , +#endif + repositoryLookup , + + +-- ** lookupBlob #method:lookupBlob# + +#if ENABLE_OVERLOADING + RepositoryLookupBlobMethodInfo , +#endif + repositoryLookupBlob , + + +-- ** lookupBranch #method:lookupBranch# + +#if ENABLE_OVERLOADING + RepositoryLookupBranchMethodInfo , +#endif + repositoryLookupBranch , + + +-- ** lookupCommit #method:lookupCommit# + +#if ENABLE_OVERLOADING + RepositoryLookupCommitMethodInfo , +#endif + repositoryLookupCommit , + + +-- ** lookupReference #method:lookupReference# + +#if ENABLE_OVERLOADING + RepositoryLookupReferenceMethodInfo , +#endif + repositoryLookupReference , + + +-- ** lookupReferenceDwim #method:lookupReferenceDwim# + +#if ENABLE_OVERLOADING + RepositoryLookupReferenceDwimMethodInfo , +#endif + repositoryLookupReferenceDwim , + + +-- ** lookupRemote #method:lookupRemote# + +#if ENABLE_OVERLOADING + RepositoryLookupRemoteMethodInfo , +#endif + repositoryLookupRemote , + + +-- ** lookupSubmodule #method:lookupSubmodule# + +#if ENABLE_OVERLOADING + RepositoryLookupSubmoduleMethodInfo , +#endif + repositoryLookupSubmodule , + + +-- ** lookupTag #method:lookupTag# + +#if ENABLE_OVERLOADING + RepositoryLookupTagMethodInfo , +#endif + repositoryLookupTag , + + +-- ** lookupTree #method:lookupTree# + +#if ENABLE_OVERLOADING + RepositoryLookupTreeMethodInfo , +#endif + repositoryLookupTree , + + +-- ** mergeCommits #method:mergeCommits# + +#if ENABLE_OVERLOADING + RepositoryMergeCommitsMethodInfo , +#endif + repositoryMergeCommits , + + +-- ** mergeTrees #method:mergeTrees# + +#if ENABLE_OVERLOADING + RepositoryMergeTreesMethodInfo , +#endif + repositoryMergeTrees , + + +-- ** noteForeach #method:noteForeach# + +#if ENABLE_OVERLOADING + RepositoryNoteForeachMethodInfo , +#endif + repositoryNoteForeach , + + +-- ** open #method:open# + + repositoryOpen , + + +-- ** pathIsIgnored #method:pathIsIgnored# + +#if ENABLE_OVERLOADING + RepositoryPathIsIgnoredMethodInfo , +#endif + repositoryPathIsIgnored , + + +-- ** readNote #method:readNote# + +#if ENABLE_OVERLOADING + RepositoryReadNoteMethodInfo , +#endif + repositoryReadNote , + + +-- ** rebaseInit #method:rebaseInit# + +#if ENABLE_OVERLOADING + RepositoryRebaseInitMethodInfo , +#endif + repositoryRebaseInit , + + +-- ** rebaseOpen #method:rebaseOpen# + +#if ENABLE_OVERLOADING + RepositoryRebaseOpenMethodInfo , +#endif + repositoryRebaseOpen , + + +-- ** referencesForeach #method:referencesForeach# + +#if ENABLE_OVERLOADING + RepositoryReferencesForeachMethodInfo , +#endif + repositoryReferencesForeach , + + +-- ** referencesForeachName #method:referencesForeachName# + +#if ENABLE_OVERLOADING + RepositoryReferencesForeachNameMethodInfo, +#endif + repositoryReferencesForeachName , + + +-- ** removeNote #method:removeNote# + +#if ENABLE_OVERLOADING + RepositoryRemoveNoteMethodInfo , +#endif + repositoryRemoveNote , + + +-- ** reset #method:reset# + +#if ENABLE_OVERLOADING + RepositoryResetMethodInfo , +#endif + repositoryReset , + + +-- ** resetDefault #method:resetDefault# + +#if ENABLE_OVERLOADING + RepositoryResetDefaultMethodInfo , +#endif + repositoryResetDefault , + + +-- ** revert #method:revert# + +#if ENABLE_OVERLOADING + RepositoryRevertMethodInfo , +#endif + repositoryRevert , + + +-- ** revparse #method:revparse# + +#if ENABLE_OVERLOADING + RepositoryRevparseMethodInfo , +#endif + repositoryRevparse , + + +-- ** saveStash #method:saveStash# + +#if ENABLE_OVERLOADING + RepositorySaveStashMethodInfo , +#endif + repositorySaveStash , + + +-- ** setHead #method:setHead# + +#if ENABLE_OVERLOADING + RepositorySetHeadMethodInfo , +#endif + repositorySetHead , + + +-- ** setSubmoduleFetchRecurse #method:setSubmoduleFetchRecurse# + +#if ENABLE_OVERLOADING + RepositorySetSubmoduleFetchRecurseMethodInfo, +#endif + repositorySetSubmoduleFetchRecurse , + + +-- ** setSubmoduleIgnore #method:setSubmoduleIgnore# + +#if ENABLE_OVERLOADING + RepositorySetSubmoduleIgnoreMethodInfo , +#endif + repositorySetSubmoduleIgnore , + + +-- ** setSubmoduleUpdate #method:setSubmoduleUpdate# + +#if ENABLE_OVERLOADING + RepositorySetSubmoduleUpdateMethodInfo , +#endif + repositorySetSubmoduleUpdate , + + +-- ** setSubmoduleUrl #method:setSubmoduleUrl# + +#if ENABLE_OVERLOADING + RepositorySetSubmoduleUrlMethodInfo , +#endif + repositorySetSubmoduleUrl , + + +-- ** setWorkdir #method:setWorkdir# + +#if ENABLE_OVERLOADING + RepositorySetWorkdirMethodInfo , +#endif + repositorySetWorkdir , + + +-- ** stashForeach #method:stashForeach# + +#if ENABLE_OVERLOADING + RepositoryStashForeachMethodInfo , +#endif + repositoryStashForeach , + + +-- ** submoduleForeach #method:submoduleForeach# + +#if ENABLE_OVERLOADING + RepositorySubmoduleForeachMethodInfo , +#endif + repositorySubmoduleForeach , + + +-- ** tagForeach #method:tagForeach# + +#if ENABLE_OVERLOADING + RepositoryTagForeachMethodInfo , +#endif + repositoryTagForeach , + + + + + -- * Properties +-- ** cloneOptions #attr:cloneOptions# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RepositoryCloneOptionsPropertyInfo , +#endif + constructRepositoryCloneOptions , + getRepositoryCloneOptions , +#if ENABLE_OVERLOADING + repositoryCloneOptions , +#endif + + +-- ** head #attr:head# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RepositoryHeadPropertyInfo , +#endif + getRepositoryHead , +#if ENABLE_OVERLOADING + repositoryHead , +#endif + + +-- ** init #attr:init# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RepositoryInitPropertyInfo , +#endif + constructRepositoryInit , + getRepositoryInit , +#if ENABLE_OVERLOADING + repositoryInit , +#endif + + +-- ** isBare #attr:isBare# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RepositoryIsBarePropertyInfo , +#endif + constructRepositoryIsBare , + getRepositoryIsBare , + + +-- ** location #attr:location# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RepositoryLocationPropertyInfo , +#endif + constructRepositoryLocation , + getRepositoryLocation , +#if ENABLE_OVERLOADING + repositoryLocation , +#endif + + +-- ** url #attr:url# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RepositoryUrlPropertyInfo , +#endif + constructRepositoryUrl , + getRepositoryUrl , +#if ENABLE_OVERLOADING + repositoryUrl , +#endif + + +-- ** workdir #attr:workdir# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RepositoryWorkdirPropertyInfo , +#endif + clearRepositoryWorkdir , + constructRepositoryWorkdir , + getRepositoryWorkdir , +#if ENABLE_OVERLOADING + repositoryWorkdir , +#endif + setRepositoryWorkdir , + + + + + ) 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 qualified GI.Ggit.Callbacks as Ggit.Callbacks +import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags +import {-# SOURCE #-} qualified GI.Ggit.Objects.Blame as Ggit.Blame +import {-# SOURCE #-} qualified GI.Ggit.Objects.Blob as Ggit.Blob +import {-# SOURCE #-} qualified GI.Ggit.Objects.BlobOutputStream as Ggit.BlobOutputStream +import {-# SOURCE #-} qualified GI.Ggit.Objects.Branch as Ggit.Branch +import {-# SOURCE #-} qualified GI.Ggit.Objects.CheckoutOptions as Ggit.CheckoutOptions +import {-# SOURCE #-} qualified GI.Ggit.Objects.CherryPickOptions as Ggit.CherryPickOptions +import {-# SOURCE #-} qualified GI.Ggit.Objects.CloneOptions as Ggit.CloneOptions +import {-# SOURCE #-} qualified GI.Ggit.Objects.Commit as Ggit.Commit +import {-# SOURCE #-} qualified GI.Ggit.Objects.Config as Ggit.Config +import {-# SOURCE #-} qualified GI.Ggit.Objects.Index as Ggit.Index +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Rebase as Ggit.Rebase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Ref as Ggit.Ref +import {-# SOURCE #-} qualified GI.Ggit.Objects.Remote as Ggit.Remote +import {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Objects.Tag as Ggit.Tag +import {-# SOURCE #-} qualified GI.Ggit.Objects.Tree as Ggit.Tree +import {-# SOURCE #-} qualified GI.Ggit.Objects.TreeBuilder as Ggit.TreeBuilder +import {-# SOURCE #-} qualified GI.Ggit.Structs.AnnotatedCommit as Ggit.AnnotatedCommit +import {-# SOURCE #-} qualified GI.Ggit.Structs.BlameOptions as Ggit.BlameOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.BranchEnumerator as Ggit.BranchEnumerator +import {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntry as Ggit.IndexEntry +import {-# SOURCE #-} qualified GI.Ggit.Structs.MergeOptions as Ggit.MergeOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.Note as Ggit.Note +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.RebaseOptions as Ggit.RebaseOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.RevertOptions as Ggit.RevertOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.StatusOptions as Ggit.StatusOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.Submodule as Ggit.Submodule +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Interfaces.Initable as Gio.Initable + +-- | Memory-managed wrapper type. +newtype Repository = Repository (ManagedPtr Repository) +foreign import ccall "ggit_repository_get_type" + c_ggit_repository_get_type :: IO GType + +instance GObject Repository where + gobjectType = c_ggit_repository_get_type + + +-- | Type class for types which can be safely cast to `Repository`, for instance with `toRepository`. +class (GObject o, O.IsDescendantOf Repository o) => IsRepository o +instance (GObject o, O.IsDescendantOf Repository o) => IsRepository o + +instance O.HasParentTypes Repository +type instance O.ParentTypes Repository = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `Repository`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepository :: (MonadIO m, IsRepository o) => o -> m Repository +toRepository = liftIO . unsafeCastTo Repository + +-- | A convenience alias for `Nothing` :: `Maybe` `Repository`. +noRepository :: Maybe Repository +noRepository = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepositoryMethod (t :: Symbol) (o :: *) :: * where + ResolveRepositoryMethod "addRemoteFetch" o = RepositoryAddRemoteFetchMethodInfo + ResolveRepositoryMethod "addRemotePush" o = RepositoryAddRemotePushMethodInfo + ResolveRepositoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepositoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepositoryMethod "blameFile" o = RepositoryBlameFileMethodInfo + ResolveRepositoryMethod "checkoutHead" o = RepositoryCheckoutHeadMethodInfo + ResolveRepositoryMethod "checkoutIndex" o = RepositoryCheckoutIndexMethodInfo + ResolveRepositoryMethod "checkoutTree" o = RepositoryCheckoutTreeMethodInfo + ResolveRepositoryMethod "cherryPick" o = RepositoryCherryPickMethodInfo + ResolveRepositoryMethod "cherryPickCommit" o = RepositoryCherryPickCommitMethodInfo + ResolveRepositoryMethod "createBlob" o = RepositoryCreateBlobMethodInfo + ResolveRepositoryMethod "createBlobFromBuffer" o = RepositoryCreateBlobFromBufferMethodInfo + ResolveRepositoryMethod "createBlobFromFile" o = RepositoryCreateBlobFromFileMethodInfo + ResolveRepositoryMethod "createBlobFromPath" o = RepositoryCreateBlobFromPathMethodInfo + ResolveRepositoryMethod "createBranch" o = RepositoryCreateBranchMethodInfo + ResolveRepositoryMethod "createCommit" o = RepositoryCreateCommitMethodInfo + ResolveRepositoryMethod "createCommitFromIds" o = RepositoryCreateCommitFromIdsMethodInfo + ResolveRepositoryMethod "createIndexEntryForFile" o = RepositoryCreateIndexEntryForFileMethodInfo + ResolveRepositoryMethod "createIndexEntryForPath" o = RepositoryCreateIndexEntryForPathMethodInfo + ResolveRepositoryMethod "createNote" o = RepositoryCreateNoteMethodInfo + ResolveRepositoryMethod "createReference" o = RepositoryCreateReferenceMethodInfo + ResolveRepositoryMethod "createRemote" o = RepositoryCreateRemoteMethodInfo + ResolveRepositoryMethod "createSymbolicReference" o = RepositoryCreateSymbolicReferenceMethodInfo + ResolveRepositoryMethod "createTag" o = RepositoryCreateTagMethodInfo + ResolveRepositoryMethod "createTagAnnotation" o = RepositoryCreateTagAnnotationMethodInfo + ResolveRepositoryMethod "createTagFromBuffer" o = RepositoryCreateTagFromBufferMethodInfo + ResolveRepositoryMethod "createTagLightweight" o = RepositoryCreateTagLightweightMethodInfo + ResolveRepositoryMethod "createTreeBuilder" o = RepositoryCreateTreeBuilderMethodInfo + ResolveRepositoryMethod "createTreeBuilderFromTree" o = RepositoryCreateTreeBuilderFromTreeMethodInfo + ResolveRepositoryMethod "deleteTag" o = RepositoryDeleteTagMethodInfo + ResolveRepositoryMethod "dropStash" o = RepositoryDropStashMethodInfo + ResolveRepositoryMethod "enumerateBranches" o = RepositoryEnumerateBranchesMethodInfo + ResolveRepositoryMethod "fileStatus" o = RepositoryFileStatusMethodInfo + ResolveRepositoryMethod "fileStatusForeach" o = RepositoryFileStatusForeachMethodInfo + ResolveRepositoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepositoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepositoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepositoryMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveRepositoryMethod "isBare" o = RepositoryIsBareMethodInfo + ResolveRepositoryMethod "isEmpty" o = RepositoryIsEmptyMethodInfo + ResolveRepositoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepositoryMethod "isHeadDetached" o = RepositoryIsHeadDetachedMethodInfo + ResolveRepositoryMethod "isHeadUnborn" o = RepositoryIsHeadUnbornMethodInfo + ResolveRepositoryMethod "listRemotes" o = RepositoryListRemotesMethodInfo + ResolveRepositoryMethod "listTags" o = RepositoryListTagsMethodInfo + ResolveRepositoryMethod "listTagsMatch" o = RepositoryListTagsMatchMethodInfo + ResolveRepositoryMethod "lookup" o = RepositoryLookupMethodInfo + ResolveRepositoryMethod "lookupBlob" o = RepositoryLookupBlobMethodInfo + ResolveRepositoryMethod "lookupBranch" o = RepositoryLookupBranchMethodInfo + ResolveRepositoryMethod "lookupCommit" o = RepositoryLookupCommitMethodInfo + ResolveRepositoryMethod "lookupReference" o = RepositoryLookupReferenceMethodInfo + ResolveRepositoryMethod "lookupReferenceDwim" o = RepositoryLookupReferenceDwimMethodInfo + ResolveRepositoryMethod "lookupRemote" o = RepositoryLookupRemoteMethodInfo + ResolveRepositoryMethod "lookupSubmodule" o = RepositoryLookupSubmoduleMethodInfo + ResolveRepositoryMethod "lookupTag" o = RepositoryLookupTagMethodInfo + ResolveRepositoryMethod "lookupTree" o = RepositoryLookupTreeMethodInfo + ResolveRepositoryMethod "mergeCommits" o = RepositoryMergeCommitsMethodInfo + ResolveRepositoryMethod "mergeTrees" o = RepositoryMergeTreesMethodInfo + ResolveRepositoryMethod "noteForeach" o = RepositoryNoteForeachMethodInfo + ResolveRepositoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepositoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepositoryMethod "pathIsIgnored" o = RepositoryPathIsIgnoredMethodInfo + ResolveRepositoryMethod "readNote" o = RepositoryReadNoteMethodInfo + ResolveRepositoryMethod "rebaseInit" o = RepositoryRebaseInitMethodInfo + ResolveRepositoryMethod "rebaseOpen" o = RepositoryRebaseOpenMethodInfo + ResolveRepositoryMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepositoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepositoryMethod "referencesForeach" o = RepositoryReferencesForeachMethodInfo + ResolveRepositoryMethod "referencesForeachName" o = RepositoryReferencesForeachNameMethodInfo + ResolveRepositoryMethod "removeNote" o = RepositoryRemoveNoteMethodInfo + ResolveRepositoryMethod "reset" o = RepositoryResetMethodInfo + ResolveRepositoryMethod "resetDefault" o = RepositoryResetDefaultMethodInfo + ResolveRepositoryMethod "revert" o = RepositoryRevertMethodInfo + ResolveRepositoryMethod "revparse" o = RepositoryRevparseMethodInfo + ResolveRepositoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepositoryMethod "saveStash" o = RepositorySaveStashMethodInfo + ResolveRepositoryMethod "stashForeach" o = RepositoryStashForeachMethodInfo + ResolveRepositoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepositoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepositoryMethod "submoduleForeach" o = RepositorySubmoduleForeachMethodInfo + ResolveRepositoryMethod "tagForeach" o = RepositoryTagForeachMethodInfo + ResolveRepositoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepositoryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepositoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepositoryMethod "getAheadBehind" o = RepositoryGetAheadBehindMethodInfo + ResolveRepositoryMethod "getAttribute" o = RepositoryGetAttributeMethodInfo + ResolveRepositoryMethod "getConfig" o = RepositoryGetConfigMethodInfo + ResolveRepositoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepositoryMethod "getDefaultNotesRef" o = RepositoryGetDefaultNotesRefMethodInfo + ResolveRepositoryMethod "getDescendantOf" o = RepositoryGetDescendantOfMethodInfo + ResolveRepositoryMethod "getHead" o = RepositoryGetHeadMethodInfo + ResolveRepositoryMethod "getIndex" o = RepositoryGetIndexMethodInfo + ResolveRepositoryMethod "getLocation" o = RepositoryGetLocationMethodInfo + ResolveRepositoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepositoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepositoryMethod "getSubmoduleStatus" o = RepositoryGetSubmoduleStatusMethodInfo + ResolveRepositoryMethod "getWorkdir" o = RepositoryGetWorkdirMethodInfo + ResolveRepositoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepositoryMethod "setHead" o = RepositorySetHeadMethodInfo + ResolveRepositoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepositoryMethod "setSubmoduleFetchRecurse" o = RepositorySetSubmoduleFetchRecurseMethodInfo + ResolveRepositoryMethod "setSubmoduleIgnore" o = RepositorySetSubmoduleIgnoreMethodInfo + ResolveRepositoryMethod "setSubmoduleUpdate" o = RepositorySetSubmoduleUpdateMethodInfo + ResolveRepositoryMethod "setSubmoduleUrl" o = RepositorySetSubmoduleUrlMethodInfo + ResolveRepositoryMethod "setWorkdir" o = RepositorySetWorkdirMethodInfo + ResolveRepositoryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepositoryMethod t Repository, O.MethodInfo info Repository p) => OL.IsLabel t (Repository -> 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 + +-- VVV Prop "clone-options" + -- Type: TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@clone-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repository #cloneOptions +@ +-} +getRepositoryCloneOptions :: (MonadIO m, IsRepository o) => o -> m (Maybe Ggit.CloneOptions.CloneOptions) +getRepositoryCloneOptions obj = liftIO $ B.Properties.getObjectPropertyObject obj "clone-options" Ggit.CloneOptions.CloneOptions + +{- | +Construct a `GValueConstruct` with valid value for the “@clone-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepositoryCloneOptions :: (IsRepository o, Ggit.CloneOptions.IsCloneOptions a) => a -> IO (GValueConstruct o) +constructRepositoryCloneOptions val = B.Properties.constructObjectPropertyObject "clone-options" (Just val) + +#if ENABLE_OVERLOADING +data RepositoryCloneOptionsPropertyInfo +instance AttrInfo RepositoryCloneOptionsPropertyInfo where + type AttrAllowedOps RepositoryCloneOptionsPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepositoryCloneOptionsPropertyInfo = Ggit.CloneOptions.IsCloneOptions + type AttrBaseTypeConstraint RepositoryCloneOptionsPropertyInfo = IsRepository + type AttrGetType RepositoryCloneOptionsPropertyInfo = (Maybe Ggit.CloneOptions.CloneOptions) + type AttrLabel RepositoryCloneOptionsPropertyInfo = "clone-options" + type AttrOrigin RepositoryCloneOptionsPropertyInfo = Repository + attrGet _ = getRepositoryCloneOptions + attrSet _ = undefined + attrConstruct _ = constructRepositoryCloneOptions + attrClear _ = undefined +#endif + +-- VVV Prop "head" + -- Type: TInterface (Name {namespace = "Ggit", name = "Ref"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@head@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repository #head +@ +-} +getRepositoryHead :: (MonadIO m, IsRepository o) => o -> m (Maybe Ggit.Ref.Ref) +getRepositoryHead obj = liftIO $ B.Properties.getObjectPropertyObject obj "head" Ggit.Ref.Ref + +#if ENABLE_OVERLOADING +data RepositoryHeadPropertyInfo +instance AttrInfo RepositoryHeadPropertyInfo where + type AttrAllowedOps RepositoryHeadPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepositoryHeadPropertyInfo = (~) () + type AttrBaseTypeConstraint RepositoryHeadPropertyInfo = IsRepository + type AttrGetType RepositoryHeadPropertyInfo = (Maybe Ggit.Ref.Ref) + type AttrLabel RepositoryHeadPropertyInfo = "head" + type AttrOrigin RepositoryHeadPropertyInfo = Repository + attrGet _ = getRepositoryHead + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "init" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@init@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repository #init +@ +-} +getRepositoryInit :: (MonadIO m, IsRepository o) => o -> m Bool +getRepositoryInit obj = liftIO $ B.Properties.getObjectPropertyBool obj "init" + +{- | +Construct a `GValueConstruct` with valid value for the “@init@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepositoryInit :: (IsRepository o) => Bool -> IO (GValueConstruct o) +constructRepositoryInit val = B.Properties.constructObjectPropertyBool "init" val + +#if ENABLE_OVERLOADING +data RepositoryInitPropertyInfo +instance AttrInfo RepositoryInitPropertyInfo where + type AttrAllowedOps RepositoryInitPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint RepositoryInitPropertyInfo = (~) Bool + type AttrBaseTypeConstraint RepositoryInitPropertyInfo = IsRepository + type AttrGetType RepositoryInitPropertyInfo = Bool + type AttrLabel RepositoryInitPropertyInfo = "init" + type AttrOrigin RepositoryInitPropertyInfo = Repository + attrGet _ = getRepositoryInit + attrSet _ = undefined + attrConstruct _ = constructRepositoryInit + attrClear _ = undefined +#endif + +-- VVV Prop "is-bare" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-bare@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repository #isBare +@ +-} +getRepositoryIsBare :: (MonadIO m, IsRepository o) => o -> m Bool +getRepositoryIsBare obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-bare" + +{- | +Construct a `GValueConstruct` with valid value for the “@is-bare@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepositoryIsBare :: (IsRepository o) => Bool -> IO (GValueConstruct o) +constructRepositoryIsBare val = B.Properties.constructObjectPropertyBool "is-bare" val + +#if ENABLE_OVERLOADING +data RepositoryIsBarePropertyInfo +instance AttrInfo RepositoryIsBarePropertyInfo where + type AttrAllowedOps RepositoryIsBarePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint RepositoryIsBarePropertyInfo = (~) Bool + type AttrBaseTypeConstraint RepositoryIsBarePropertyInfo = IsRepository + type AttrGetType RepositoryIsBarePropertyInfo = Bool + type AttrLabel RepositoryIsBarePropertyInfo = "is-bare" + type AttrOrigin RepositoryIsBarePropertyInfo = Repository + attrGet _ = getRepositoryIsBare + attrSet _ = undefined + attrConstruct _ = constructRepositoryIsBare + attrClear _ = undefined +#endif + +-- VVV Prop "location" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@location@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repository #location +@ +-} +getRepositoryLocation :: (MonadIO m, IsRepository o) => o -> m (Maybe Gio.File.File) +getRepositoryLocation obj = liftIO $ B.Properties.getObjectPropertyObject obj "location" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@location@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepositoryLocation :: (IsRepository o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructRepositoryLocation val = B.Properties.constructObjectPropertyObject "location" (Just val) + +#if ENABLE_OVERLOADING +data RepositoryLocationPropertyInfo +instance AttrInfo RepositoryLocationPropertyInfo where + type AttrAllowedOps RepositoryLocationPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepositoryLocationPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint RepositoryLocationPropertyInfo = IsRepository + type AttrGetType RepositoryLocationPropertyInfo = (Maybe Gio.File.File) + type AttrLabel RepositoryLocationPropertyInfo = "location" + type AttrOrigin RepositoryLocationPropertyInfo = Repository + attrGet _ = getRepositoryLocation + attrSet _ = undefined + attrConstruct _ = constructRepositoryLocation + attrClear _ = undefined +#endif + +-- VVV Prop "url" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@url@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repository #url +@ +-} +getRepositoryUrl :: (MonadIO m, IsRepository o) => o -> m (Maybe T.Text) +getRepositoryUrl obj = liftIO $ B.Properties.getObjectPropertyString obj "url" + +{- | +Construct a `GValueConstruct` with valid value for the “@url@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepositoryUrl :: (IsRepository o) => T.Text -> IO (GValueConstruct o) +constructRepositoryUrl val = B.Properties.constructObjectPropertyString "url" (Just val) + +#if ENABLE_OVERLOADING +data RepositoryUrlPropertyInfo +instance AttrInfo RepositoryUrlPropertyInfo where + type AttrAllowedOps RepositoryUrlPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepositoryUrlPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint RepositoryUrlPropertyInfo = IsRepository + type AttrGetType RepositoryUrlPropertyInfo = (Maybe T.Text) + type AttrLabel RepositoryUrlPropertyInfo = "url" + type AttrOrigin RepositoryUrlPropertyInfo = Repository + attrGet _ = getRepositoryUrl + attrSet _ = undefined + attrConstruct _ = constructRepositoryUrl + attrClear _ = undefined +#endif + +-- VVV Prop "workdir" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@workdir@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' repository #workdir +@ +-} +getRepositoryWorkdir :: (MonadIO m, IsRepository o) => o -> m (Maybe Gio.File.File) +getRepositoryWorkdir obj = liftIO $ B.Properties.getObjectPropertyObject obj "workdir" Gio.File.File + +{- | +Set the value of the “@workdir@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' repository [ #workdir 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRepositoryWorkdir :: (MonadIO m, IsRepository o, Gio.File.IsFile a) => o -> a -> m () +setRepositoryWorkdir obj val = liftIO $ B.Properties.setObjectPropertyObject obj "workdir" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@workdir@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRepositoryWorkdir :: (IsRepository o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructRepositoryWorkdir val = B.Properties.constructObjectPropertyObject "workdir" (Just val) + +{- | +Set the value of the “@workdir@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #workdir +@ +-} +clearRepositoryWorkdir :: (MonadIO m, IsRepository o) => o -> m () +clearRepositoryWorkdir obj = liftIO $ B.Properties.setObjectPropertyObject obj "workdir" (Nothing :: Maybe Gio.File.File) + +#if ENABLE_OVERLOADING +data RepositoryWorkdirPropertyInfo +instance AttrInfo RepositoryWorkdirPropertyInfo where + type AttrAllowedOps RepositoryWorkdirPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RepositoryWorkdirPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint RepositoryWorkdirPropertyInfo = IsRepository + type AttrGetType RepositoryWorkdirPropertyInfo = (Maybe Gio.File.File) + type AttrLabel RepositoryWorkdirPropertyInfo = "workdir" + type AttrOrigin RepositoryWorkdirPropertyInfo = Repository + attrGet _ = getRepositoryWorkdir + attrSet _ = setRepositoryWorkdir + attrConstruct _ = constructRepositoryWorkdir + attrClear _ = clearRepositoryWorkdir +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Repository +type instance O.AttributeList Repository = RepositoryAttributeList +type RepositoryAttributeList = ('[ '("cloneOptions", RepositoryCloneOptionsPropertyInfo), '("head", RepositoryHeadPropertyInfo), '("init", RepositoryInitPropertyInfo), '("isBare", RepositoryIsBarePropertyInfo), '("location", RepositoryLocationPropertyInfo), '("native", Ggit.Native.NativeNativePropertyInfo), '("url", RepositoryUrlPropertyInfo), '("workdir", RepositoryWorkdirPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +repositoryCloneOptions :: AttrLabelProxy "cloneOptions" +repositoryCloneOptions = AttrLabelProxy + +repositoryHead :: AttrLabelProxy "head" +repositoryHead = AttrLabelProxy + +repositoryInit :: AttrLabelProxy "init" +repositoryInit = AttrLabelProxy + +repositoryLocation :: AttrLabelProxy "location" +repositoryLocation = AttrLabelProxy + +repositoryUrl :: AttrLabelProxy "url" +repositoryUrl = AttrLabelProxy + +repositoryWorkdir :: AttrLabelProxy "workdir" +repositoryWorkdir = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Repository = RepositorySignalList +type RepositorySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Repository::add_remote_fetch +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the fetch refspec.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_add_remote_fetch" ggit_repository_add_remote_fetch :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Remote.Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + CString -> -- refspec : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Adds a fetch refspec to the /@remote@/\'s configuration. +Adds /@refspec@/ to the fetch list in the configuration. No +loaded remote instances will be affected. +-} +repositoryAddRemoteFetch :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Remote.IsRemote b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> T.Text + {- ^ /@refspec@/: the fetch refspec. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryAddRemoteFetch repository remote refspec = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + remote' <- unsafeManagedPtrCastPtr remote + refspec' <- textToCString refspec + onException (do + propagateGError $ ggit_repository_add_remote_fetch repository' remote' refspec' + touchManagedPtr repository + touchManagedPtr remote + freeMem refspec' + return () + ) (do + freeMem refspec' + ) + +#if ENABLE_OVERLOADING +data RepositoryAddRemoteFetchMethodInfo +instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsRepository a, Ggit.Remote.IsRemote b) => O.MethodInfo RepositoryAddRemoteFetchMethodInfo a signature where + overloadedMethod _ = repositoryAddRemoteFetch + +#endif + +-- method Repository::add_remote_push +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "remote", argType = TInterface (Name {namespace = "Ggit", name = "Remote"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the push refspec.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_add_remote_push" ggit_repository_add_remote_push :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Remote.Remote -> -- remote : TInterface (Name {namespace = "Ggit", name = "Remote"}) + CString -> -- refspec : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Adds a push refspec to /@remote@/\'s configuration. +Adds the given refspec to the push list in the configuration. No +loaded remote instances will be affected. +-} +repositoryAddRemotePush :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Remote.IsRemote b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@remote@/: a 'GI.Ggit.Objects.Remote.Remote'. -} + -> T.Text + {- ^ /@refspec@/: the push refspec. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryAddRemotePush repository remote refspec = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + remote' <- unsafeManagedPtrCastPtr remote + refspec' <- textToCString refspec + onException (do + propagateGError $ ggit_repository_add_remote_push repository' remote' refspec' + touchManagedPtr repository + touchManagedPtr remote + freeMem refspec' + return () + ) (do + freeMem refspec' + ) + +#if ENABLE_OVERLOADING +data RepositoryAddRemotePushMethodInfo +instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsRepository a, Ggit.Remote.IsRemote b) => O.MethodInfo RepositoryAddRemotePushMethodInfo a signature where + overloadedMethod _ = repositoryAddRemotePush + +#endif + +-- method Repository::blame_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file to blame.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "blame options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Blame"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_blame_file" ggit_repository_blame_file :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Ggit.BlameOptions.BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Blame.Blame) + +{- | +Get a blame for a single file. +-} +repositoryBlameFile :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Gio.File.IsFile b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@file@/: the file to blame. -} + -> Maybe (Ggit.BlameOptions.BlameOptions) + {- ^ /@blameOptions@/: blame options. -} + -> m (Maybe Ggit.Blame.Blame) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Blame.Blame'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryBlameFile repository file blameOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + file' <- unsafeManagedPtrCastPtr file + maybeBlameOptions <- case blameOptions of + Nothing -> return nullPtr + Just jBlameOptions -> do + jBlameOptions' <- unsafeManagedPtrGetPtr jBlameOptions + return jBlameOptions' + onException (do + result <- propagateGError $ ggit_repository_blame_file repository' file' maybeBlameOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Blame.Blame) result' + return result'' + touchManagedPtr repository + touchManagedPtr file + whenJust blameOptions touchManagedPtr + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryBlameFileMethodInfo +instance (signature ~ (b -> Maybe (Ggit.BlameOptions.BlameOptions) -> m (Maybe Ggit.Blame.Blame)), MonadIO m, IsRepository a, Gio.File.IsFile b) => O.MethodInfo RepositoryBlameFileMethodInfo a signature where + overloadedMethod _ = repositoryBlameFile + +#endif + +-- method Repository::checkout_head +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_checkout_head" ggit_repository_checkout_head :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Update files in the working tree to reflect the contents of current HEAD. If +/@options@/ is 'Nothing', then the default checkout options will be used. + +If the checkout was not successfull, then /@error@/ will be set. +-} +repositoryCheckoutHead :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.CheckoutOptions.IsCheckoutOptions b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' or 'Nothing'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCheckoutHead repository options = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrCastPtr jOptions + return jOptions' + onException (do + _ <- propagateGError $ ggit_repository_checkout_head repository' maybeOptions + touchManagedPtr repository + whenJust options touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCheckoutHeadMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepository a, Ggit.CheckoutOptions.IsCheckoutOptions b) => O.MethodInfo RepositoryCheckoutHeadMethodInfo a signature where + overloadedMethod _ = repositoryCheckoutHead + +#endif + +-- method Repository::checkout_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TInterface (Name {namespace = "Ggit", name = "Index"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitIndex or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_checkout_index" ggit_repository_checkout_index :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Index.Index -> -- index : TInterface (Name {namespace = "Ggit", name = "Index"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Update files in the working tree to reflect the contents of the index. If +/@index@/ is 'Nothing', then the current index of the repository will be used. If +/@options@/ is 'Nothing', then the default checkout options will be used. + +If the checkout was not successfull, then /@error@/ will be set. +-} +repositoryCheckoutIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Index.IsIndex b, Ggit.CheckoutOptions.IsCheckoutOptions c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@index@/: a 'GI.Ggit.Objects.Index.Index' or 'Nothing'. -} + -> Maybe (c) + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' or 'Nothing'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCheckoutIndex repository index options = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeIndex <- case index of + Nothing -> return nullPtr + Just jIndex -> do + jIndex' <- unsafeManagedPtrCastPtr jIndex + return jIndex' + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrCastPtr jOptions + return jOptions' + onException (do + _ <- propagateGError $ ggit_repository_checkout_index repository' maybeIndex maybeOptions + touchManagedPtr repository + whenJust index touchManagedPtr + whenJust options touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCheckoutIndexMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepository a, Ggit.Index.IsIndex b, Ggit.CheckoutOptions.IsCheckoutOptions c) => O.MethodInfo RepositoryCheckoutIndexMethodInfo a signature where + overloadedMethod _ = repositoryCheckoutIndex + +#endif + +-- method Repository::checkout_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitObject or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_checkout_tree" ggit_repository_checkout_tree :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Object.Object -> -- tree : TInterface (Name {namespace = "Ggit", name = "Object"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Update files in the working tree to reflect the contents of the specified +commit, tag or tree object. If /@tree@/ is 'Nothing', then the current HEAD of the +repository will be used. If /@options@/ is 'Nothing', then the default checkout +options will be used. + +If the checkout was not successfull, then /@error@/ will be set. +-} +repositoryCheckoutTree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.CheckoutOptions.IsCheckoutOptions c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@tree@/: a 'GI.Ggit.Objects.Object.Object' or 'Nothing'. -} + -> Maybe (c) + {- ^ /@options@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' or 'Nothing'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCheckoutTree repository tree options = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeTree <- case tree of + Nothing -> return nullPtr + Just jTree -> do + jTree' <- unsafeManagedPtrCastPtr jTree + return jTree' + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrCastPtr jOptions + return jOptions' + onException (do + _ <- propagateGError $ ggit_repository_checkout_tree repository' maybeTree maybeOptions + touchManagedPtr repository + whenJust tree touchManagedPtr + whenJust options touchManagedPtr + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCheckoutTreeMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.CheckoutOptions.IsCheckoutOptions c) => O.MethodInfo RepositoryCheckoutTreeMethodInfo a signature where + overloadedMethod _ = repositoryCheckoutTree + +#endif + +-- method Repository::cherry_pick +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCherryPickOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_cherry_pick" ggit_repository_cherry_pick :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Commit.Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + Ptr Ggit.CherryPickOptions.CherryPickOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CherryPickOptions"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Cherry pick the specified commit, making changes in the index and the working +directory. +-} +repositoryCherryPick :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Commit.IsCommit b, Ggit.CherryPickOptions.IsCherryPickOptions c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> c + {- ^ /@options@/: a 'GI.Ggit.Objects.CherryPickOptions.CherryPickOptions'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCherryPick repository commit options = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + commit' <- unsafeManagedPtrCastPtr commit + options' <- unsafeManagedPtrCastPtr options + onException (do + _ <- propagateGError $ ggit_repository_cherry_pick repository' commit' options' + touchManagedPtr repository + touchManagedPtr commit + touchManagedPtr options + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCherryPickMethodInfo +instance (signature ~ (b -> c -> m ()), MonadIO m, IsRepository a, Ggit.Commit.IsCommit b, Ggit.CherryPickOptions.IsCherryPickOptions c) => O.MethodInfo RepositoryCherryPickMethodInfo a signature where + overloadedMethod _ = repositoryCherryPick + +#endif + +-- method Repository::cherry_pick_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit to cherry-pick.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "our_commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit to cherry-pick on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mainline", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the parent of the commit, in case of a merge commit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Index"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_cherry_pick_commit" ggit_repository_cherry_pick_commit :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Commit.Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + Ptr Ggit.Commit.Commit -> -- our_commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + Word32 -> -- mainline : TBasicType TUInt + Ptr Ggit.MergeOptions.MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Index.Index) + +{- | +Cherry-picks the given /@commit@/ against the provided /@ourCommit@/, producing +and index that reflects the result of the cherry-pick. +-} +repositoryCherryPickCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Commit.IsCommit b, Ggit.Commit.IsCommit c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit' to cherry-pick. -} + -> c + {- ^ /@ourCommit@/: a 'GI.Ggit.Objects.Commit.Commit' to cherry-pick on. -} + -> Word32 + {- ^ /@mainline@/: the parent of the commit, in case of a merge commit. -} + -> Maybe (Ggit.MergeOptions.MergeOptions) + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m (Maybe Ggit.Index.Index) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Index.Index'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCherryPickCommit repository commit ourCommit mainline mergeOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + commit' <- unsafeManagedPtrCastPtr commit + ourCommit' <- unsafeManagedPtrCastPtr ourCommit + maybeMergeOptions <- case mergeOptions of + Nothing -> return nullPtr + Just jMergeOptions -> do + jMergeOptions' <- unsafeManagedPtrGetPtr jMergeOptions + return jMergeOptions' + onException (do + result <- propagateGError $ ggit_repository_cherry_pick_commit repository' commit' ourCommit' mainline maybeMergeOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Index.Index) result' + return result'' + touchManagedPtr repository + touchManagedPtr commit + touchManagedPtr ourCommit + whenJust mergeOptions touchManagedPtr + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCherryPickCommitMethodInfo +instance (signature ~ (b -> c -> Word32 -> Maybe (Ggit.MergeOptions.MergeOptions) -> m (Maybe Ggit.Index.Index)), MonadIO m, IsRepository a, Ggit.Commit.IsCommit b, Ggit.Commit.IsCommit c) => O.MethodInfo RepositoryCherryPickCommitMethodInfo a signature where + overloadedMethod _ = repositoryCherryPickCommit + +#endif + +-- method Repository::create_blob +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlobOutputStream"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_repository_create_blob" ggit_repository_create_blob :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + IO (Ptr Ggit.BlobOutputStream.BlobOutputStream) + +{- | +Create a new blob and return a 'GI.Gio.Objects.OutputStream.OutputStream' to write contents to the blob. +This is an efficient way to create new blobs without copying data. The +blob id can be obtained from the blob output stream using +@/ggit_blob_output_stream_get_id/@, after you close the stream. +-} +repositoryCreateBlob :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Ggit.BlobOutputStream.BlobOutputStream) + {- ^ __Returns:__ a 'GI.Ggit.Objects.BlobOutputStream.BlobOutputStream'. -} +repositoryCreateBlob repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + result <- ggit_repository_create_blob repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.BlobOutputStream.BlobOutputStream) result' + return result'' + touchManagedPtr repository + return maybeResult + +#if ENABLE_OVERLOADING +data RepositoryCreateBlobMethodInfo +instance (signature ~ (m (Maybe Ggit.BlobOutputStream.BlobOutputStream)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateBlobMethodInfo a signature where + overloadedMethod _ = repositoryCreateBlob + +#endif + +-- method Repository::create_blob_from_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length (in bytes) of the data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length (in bytes) of the data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_blob_from_buffer" ggit_repository_create_blob_from_buffer :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Word8 -> -- buffer : TCArray False (-1) 2 (TBasicType TUInt8) + Word64 -> -- size : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Write an in-memory buffer to the object database as a blob. +-} +repositoryCreateBlobFromBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> ByteString + {- ^ /@buffer@/: the data. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the new @/GgitOid/@ of the written blob, +or 'Nothing' if writing the blob failed. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateBlobFromBuffer repository buffer = liftIO $ do + let size = fromIntegral $ B.length buffer + repository' <- unsafeManagedPtrCastPtr repository + buffer' <- packByteString buffer + onException (do + result <- propagateGError $ ggit_repository_create_blob_from_buffer repository' buffer' size + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + freeMem buffer' + return maybeResult + ) (do + freeMem buffer' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateBlobFromBufferMethodInfo +instance (signature ~ (ByteString -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateBlobFromBufferMethodInfo a signature where + overloadedMethod _ = repositoryCreateBlobFromBuffer + +#endif + +-- method Repository::create_blob_from_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_blob_from_file" ggit_repository_create_blob_from_file :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Write a file to the object database as a blob. + +Returns (transfer full) (nullable): the new @/GgitOid/@ of the written blob, +or 'Nothing' if writing the blob failed. +-} +repositoryCreateBlobFromFile :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Gio.File.IsFile b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@file@/: a 'GI.Gio.Interfaces.File.File'. -} + -> m Ggit.OId.OId + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateBlobFromFile repository file = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + file' <- unsafeManagedPtrCastPtr file + onException (do + result <- propagateGError $ ggit_repository_create_blob_from_file repository' file' + checkUnexpectedReturnNULL "repositoryCreateBlobFromFile" result + result' <- (wrapBoxed Ggit.OId.OId) result + touchManagedPtr repository + touchManagedPtr file + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateBlobFromFileMethodInfo +instance (signature ~ (b -> m Ggit.OId.OId), MonadIO m, IsRepository a, Gio.File.IsFile b) => O.MethodInfo RepositoryCreateBlobFromFileMethodInfo a signature where + overloadedMethod _ = repositoryCreateBlobFromFile + +#endif + +-- method Repository::create_blob_from_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_blob_from_path" ggit_repository_create_blob_from_path :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- path : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Write a path relative to the repository working directory to the object +database as a blob. +-} +repositoryCreateBlobFromPath :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@path@/: the file path. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the new @/GgitOid/@ of the written blob, +or 'Nothing' if writing the blob failed. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateBlobFromPath repository path = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + path' <- textToCString path + onException (do + result <- propagateGError $ ggit_repository_create_blob_from_path repository' path' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + freeMem path' + return maybeResult + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateBlobFromPathMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateBlobFromPathMethodInfo a signature where + overloadedMethod _ = repositoryCreateBlobFromPath + +#endif + +-- method Repository::create_branch +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "branch_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the branch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "CreateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCreateFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Branch"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_branch" ggit_repository_create_branch :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- branch_name : TBasicType TUTF8 + Ptr Ggit.Object.Object -> -- target : TInterface (Name {namespace = "Ggit", name = "Object"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "CreateFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Branch.Branch) + +{- | +Creates a new branch pointing at a target commit. +-} +repositoryCreateBranch :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Object.IsObject b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@branchName@/: the name of the branch. -} + -> b + {- ^ /@target@/: a 'GI.Ggit.Objects.Object.Object'. -} + -> [Ggit.Flags.CreateFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.CreateFlags'. -} + -> m (Maybe Ggit.Branch.Branch) + {- ^ __Returns:__ the reference to which the branch + points, or 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateBranch repository branchName target flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + branchName' <- textToCString branchName + target' <- unsafeManagedPtrCastPtr target + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ ggit_repository_create_branch repository' branchName' target' flags' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Branch.Branch) result' + return result'' + touchManagedPtr repository + touchManagedPtr target + freeMem branchName' + return maybeResult + ) (do + freeMem branchName' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateBranchMethodInfo +instance (signature ~ (T.Text -> b -> [Ggit.Flags.CreateFlags] -> m (Maybe Ggit.Branch.Branch)), MonadIO m, IsRepository a, Ggit.Object.IsObject b) => O.MethodInfo RepositoryCreateBranchMethodInfo a signature where + overloadedMethod _ = repositoryCreateBranch + +#endif + +-- method Repository::create_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "name of the reference to update.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "author signature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "committer signature (and time of commit).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message_encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "message encoding.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "commit message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tree of objects to commit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parents", argType = TCArray False (-1) 8 (TInterface (Name {namespace = "Ggit", name = "Commit"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "parent commits.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_count", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of parent commits in @parents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "parent_count", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of parent commits in @parents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_commit" ggit_repository_create_commit :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- update_ref : TBasicType TUTF8 + Ptr Ggit.Signature.Signature -> -- author : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.Signature.Signature -> -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message_encoding : TBasicType TUTF8 + CString -> -- message : TBasicType TUTF8 + Ptr Ggit.Tree.Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr (Ptr Ggit.Commit.Commit) -> -- parents : TCArray False (-1) 8 (TInterface (Name {namespace = "Ggit", name = "Commit"})) + Int32 -> -- parent_count : TBasicType TInt + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Create a new commit. If /@updateRef@/ is not 'Nothing', the given reference will +be updated to point to the newly created commit. Use \"HEAD\" to update the +HEAD of the current branch and make it point to this commit. + +If /@messageEncoding@/ is set to 'Nothing', \"UTF-8\" encoding is assumed for the +provided /@message@/. Note that /@message@/ will not be cleaned up automatically. +You can use @/ggit_message_prettify/@ to do this yourself if needed. +-} +repositoryCreateCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c, Ggit.Tree.IsTree d) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@updateRef@/: name of the reference to update. -} + -> b + {- ^ /@author@/: author signature. -} + -> c + {- ^ /@committer@/: committer signature (and time of commit). -} + -> Maybe (T.Text) + {- ^ /@messageEncoding@/: message encoding. -} + -> T.Text + {- ^ /@message@/: commit message. -} + -> d + {- ^ /@tree@/: the tree of objects to commit. -} + -> [Ggit.Commit.Commit] + {- ^ /@parents@/: parent commits. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the 'GI.Ggit.Structs.OId.OId' of the created commit object, +or 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateCommit repository updateRef author committer messageEncoding message tree parents = liftIO $ do + let parentCount = fromIntegral $ length parents + repository' <- unsafeManagedPtrCastPtr repository + maybeUpdateRef <- case updateRef of + Nothing -> return nullPtr + Just jUpdateRef -> do + jUpdateRef' <- textToCString jUpdateRef + return jUpdateRef' + author' <- unsafeManagedPtrCastPtr author + committer' <- unsafeManagedPtrCastPtr committer + maybeMessageEncoding <- case messageEncoding of + Nothing -> return nullPtr + Just jMessageEncoding -> do + jMessageEncoding' <- textToCString jMessageEncoding + return jMessageEncoding' + message' <- textToCString message + tree' <- unsafeManagedPtrCastPtr tree + parents' <- mapM unsafeManagedPtrCastPtr parents + parents'' <- packPtrArray parents' + onException (do + result <- propagateGError $ ggit_repository_create_commit repository' maybeUpdateRef author' committer' maybeMessageEncoding message' tree' parents'' parentCount + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + touchManagedPtr author + touchManagedPtr committer + touchManagedPtr tree + mapM_ touchManagedPtr parents + freeMem maybeUpdateRef + freeMem maybeMessageEncoding + freeMem message' + freeMem parents'' + return maybeResult + ) (do + freeMem maybeUpdateRef + freeMem maybeMessageEncoding + freeMem message' + freeMem parents'' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateCommitMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> c -> Maybe (T.Text) -> T.Text -> d -> [Ggit.Commit.Commit] -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c, Ggit.Tree.IsTree d) => O.MethodInfo RepositoryCreateCommitMethodInfo a signature where + overloadedMethod _ = repositoryCreateCommit + +#endif + +-- method Repository::create_commit_from_ids +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "name of the reference to update.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "author signature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "committer signature (and time of commit).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message_encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "message encoding.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "commit message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tree of objects to commit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parents", argType = TCArray False (-1) 8 (TInterface (Name {namespace = "Ggit", name = "OId"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "parent commits.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_count", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of parent commits in @parents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "parent_count", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of parent commits in @parents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_commit_from_ids" ggit_repository_create_commit_from_ids :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- update_ref : TBasicType TUTF8 + Ptr Ggit.Signature.Signature -> -- author : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.Signature.Signature -> -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message_encoding : TBasicType TUTF8 + CString -> -- message : TBasicType TUTF8 + Ptr Ggit.OId.OId -> -- tree : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr Ggit.OId.OId) -> -- parents : TCArray False (-1) 8 (TInterface (Name {namespace = "Ggit", name = "OId"})) + Int32 -> -- parent_count : TBasicType TInt + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Create a new commit. If /@updateRef@/ is not 'Nothing', the given reference will +be updated to point to the newly created commit. Use \"HEAD\" to update the +HEAD of the current branch and make it point to this commit. + +If /@messageEncoding@/ is set to 'Nothing', \"UTF-8\" encoding is assumed for the +provided /@message@/. Note that /@message@/ will not be cleaned up automatically. +You can use @/ggit_message_prettify/@ to do this yourself if needed. +-} +repositoryCreateCommitFromIds :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@updateRef@/: name of the reference to update. -} + -> b + {- ^ /@author@/: author signature. -} + -> c + {- ^ /@committer@/: committer signature (and time of commit). -} + -> Maybe (T.Text) + {- ^ /@messageEncoding@/: message encoding. -} + -> T.Text + {- ^ /@message@/: commit message. -} + -> Ggit.OId.OId + {- ^ /@tree@/: the tree of objects to commit. -} + -> [Ggit.OId.OId] + {- ^ /@parents@/: parent commits. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the 'GI.Ggit.Structs.OId.OId' of the created commit object, +or 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateCommitFromIds repository updateRef author committer messageEncoding message tree parents = liftIO $ do + let parentCount = fromIntegral $ length parents + repository' <- unsafeManagedPtrCastPtr repository + maybeUpdateRef <- case updateRef of + Nothing -> return nullPtr + Just jUpdateRef -> do + jUpdateRef' <- textToCString jUpdateRef + return jUpdateRef' + author' <- unsafeManagedPtrCastPtr author + committer' <- unsafeManagedPtrCastPtr committer + maybeMessageEncoding <- case messageEncoding of + Nothing -> return nullPtr + Just jMessageEncoding -> do + jMessageEncoding' <- textToCString jMessageEncoding + return jMessageEncoding' + message' <- textToCString message + tree' <- unsafeManagedPtrGetPtr tree + parents' <- mapM unsafeManagedPtrGetPtr parents + parents'' <- packPtrArray parents' + onException (do + result <- propagateGError $ ggit_repository_create_commit_from_ids repository' maybeUpdateRef author' committer' maybeMessageEncoding message' tree' parents'' parentCount + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + touchManagedPtr author + touchManagedPtr committer + touchManagedPtr tree + mapM_ touchManagedPtr parents + freeMem maybeUpdateRef + freeMem maybeMessageEncoding + freeMem message' + freeMem parents'' + return maybeResult + ) (do + freeMem maybeUpdateRef + freeMem maybeMessageEncoding + freeMem message' + freeMem parents'' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateCommitFromIdsMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> c -> Maybe (T.Text) -> T.Text -> Ggit.OId.OId -> [Ggit.OId.OId] -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => O.MethodInfo RepositoryCreateCommitFromIdsMethodInfo a signature where + overloadedMethod _ = repositoryCreateCommitFromIds + +#endif + +-- method Repository::create_index_entry_for_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntry"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_index_entry_for_file" ggit_repository_create_index_entry_for_file :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Ggit.OId.OId -> -- id : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.IndexEntry.IndexEntry) + +{- | +Create a new index entry. When /@file@/ is not 'Nothing', the path of the returned +entry (@/ggit_index_entry_get_path/@) is set to the path of /@file@/ relative to +the working directory of /@repository@/. The file must reside in the working +directory of /@repository@/. The file related +fields of the returned entry are also queried from this file (if the file exists). + +If /@id@/ is not 'Nothing', then the id of the returned entry is set to /@id@/ +(see @/ggit_index_entry_get_id/@) which could point to a blob (for a file) +or a tree (for a directory). +-} +repositoryCreateIndexEntryForFile :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Gio.File.IsFile b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@file@/: a 'GI.Gio.Interfaces.File.File'. -} + -> Maybe (Ggit.OId.OId) + {- ^ /@id@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe Ggit.IndexEntry.IndexEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntry.IndexEntry' or 'Nothing' when an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateIndexEntryForFile repository file id = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeFile <- case file of + Nothing -> return nullPtr + Just jFile -> do + jFile' <- unsafeManagedPtrCastPtr jFile + return jFile' + maybeId <- case id of + Nothing -> return nullPtr + Just jId -> do + jId' <- unsafeManagedPtrGetPtr jId + return jId' + onException (do + result <- propagateGError $ ggit_repository_create_index_entry_for_file repository' maybeFile maybeId + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntry.IndexEntry) result' + return result'' + touchManagedPtr repository + whenJust file touchManagedPtr + whenJust id touchManagedPtr + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateIndexEntryForFileMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (Ggit.OId.OId) -> m (Maybe Ggit.IndexEntry.IndexEntry)), MonadIO m, IsRepository a, Gio.File.IsFile b) => O.MethodInfo RepositoryCreateIndexEntryForFileMethodInfo a signature where + overloadedMethod _ = repositoryCreateIndexEntryForFile + +#endif + +-- method Repository::create_index_entry_for_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntry"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_index_entry_for_path" ggit_repository_create_index_entry_for_path :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- path : TBasicType TUTF8 + Ptr Ggit.OId.OId -> -- id : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.IndexEntry.IndexEntry) + +{- | +Create a new index entry. When /@path@/ is not 'Nothing', the path of the returned +entry (@/ggit_index_entry_get_path/@) is set to /@path@/. The specified path can be +either absolute or relative. In the case of +an absolute path, the path must reside within the working directory of +/@repository@/. The file related fields of the returned entry are also queried +from this path (if the file exists). + +If /@id@/ is not 'Nothing', then the id of the returned entry is set to /@id@/ +(see @/ggit_index_entry_get_id/@) which could point to a blob (for a file) +or a tree (for a directory). +-} +repositoryCreateIndexEntryForPath :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@path@/: a path. -} + -> Maybe (Ggit.OId.OId) + {- ^ /@id@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe Ggit.IndexEntry.IndexEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntry.IndexEntry' or 'Nothing' when an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateIndexEntryForPath repository path id = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybePath <- case path of + Nothing -> return nullPtr + Just jPath -> do + jPath' <- textToCString jPath + return jPath' + maybeId <- case id of + Nothing -> return nullPtr + Just jId -> do + jId' <- unsafeManagedPtrGetPtr jId + return jId' + onException (do + result <- propagateGError $ ggit_repository_create_index_entry_for_path repository' maybePath maybeId + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntry.IndexEntry) result' + return result'' + touchManagedPtr repository + whenJust id touchManagedPtr + freeMem maybePath + return maybeResult + ) (do + freeMem maybePath + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateIndexEntryForPathMethodInfo +instance (signature ~ (Maybe (T.Text) -> Maybe (Ggit.OId.OId) -> m (Maybe Ggit.IndexEntry.IndexEntry)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateIndexEntryForPathMethodInfo a signature where + overloadedMethod _ = repositoryCreateIndexEntryForPath + +#endif + +-- method Repository::create_note +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notes_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "canonical name of the reference to use, or %NULL to use the default ref.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "author signature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "committer signature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "OID of the git object to decorate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "note", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "content of the note to add for object oid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "force", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to overwrite existing note.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_note" ggit_repository_create_note :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- notes_ref : TBasicType TUTF8 + Ptr Ggit.Signature.Signature -> -- author : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.Signature.Signature -> -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.OId.OId -> -- id : TInterface (Name {namespace = "Ggit", name = "OId"}) + CString -> -- note : TBasicType TUTF8 + CInt -> -- force : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Adds a note for an object. +-} +repositoryCreateNote :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@notesRef@/: canonical name of the reference to use, or 'Nothing' to use the default ref. -} + -> b + {- ^ /@author@/: author signature. -} + -> c + {- ^ /@committer@/: committer signature. -} + -> Ggit.OId.OId + {- ^ /@id@/: OID of the git object to decorate. -} + -> T.Text + {- ^ /@note@/: content of the note to add for object oid. -} + -> Bool + {- ^ /@force@/: whether to overwrite existing note. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the OID for the note or 'Nothing' in case of error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateNote repository notesRef author committer id note force = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeNotesRef <- case notesRef of + Nothing -> return nullPtr + Just jNotesRef -> do + jNotesRef' <- textToCString jNotesRef + return jNotesRef' + author' <- unsafeManagedPtrCastPtr author + committer' <- unsafeManagedPtrCastPtr committer + id' <- unsafeManagedPtrGetPtr id + note' <- textToCString note + let force' = (fromIntegral . fromEnum) force + onException (do + result <- propagateGError $ ggit_repository_create_note repository' maybeNotesRef author' committer' id' note' force' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + touchManagedPtr author + touchManagedPtr committer + touchManagedPtr id + freeMem maybeNotesRef + freeMem note' + return maybeResult + ) (do + freeMem maybeNotesRef + freeMem note' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateNoteMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> c -> Ggit.OId.OId -> T.Text -> Bool -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => O.MethodInfo RepositoryCreateNoteMethodInfo a signature where + overloadedMethod _ = repositoryCreateNote + +#endif + +-- method Repository::create_reference +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name for the new #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GgitOId pointed to by the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "log_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The one line long message to be appended to the reflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_reference" ggit_repository_create_reference :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + CString -> -- log_message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Ref.Ref) + +{- | +Creates a new object id reference. + +The reference will be created in the repository and written +to the disk. The returned value must be freed with 'GI.GObject.Objects.Object.objectUnref'. +-} +repositoryCreateReference :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name for the new 'GI.Ggit.Objects.Ref.Ref'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: the 'GI.Ggit.Structs.OId.OId' pointed to by the reference. -} + -> T.Text + {- ^ /@logMessage@/: The one line long message to be appended to the reflog. -} + -> m (Maybe Ggit.Ref.Ref) + {- ^ __Returns:__ the newly created reference. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateReference repository name oid logMessage = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + oid' <- unsafeManagedPtrGetPtr oid + logMessage' <- textToCString logMessage + onException (do + result <- propagateGError $ ggit_repository_create_reference repository' name' oid' logMessage' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Ref.Ref) result' + return result'' + touchManagedPtr repository + touchManagedPtr oid + freeMem name' + freeMem logMessage' + return maybeResult + ) (do + freeMem name' + freeMem logMessage' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateReferenceMethodInfo +instance (signature ~ (T.Text -> Ggit.OId.OId -> T.Text -> m (Maybe Ggit.Ref.Ref)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateReferenceMethodInfo a signature where + overloadedMethod _ = repositoryCreateReference + +#endif + +-- method Repository::create_remote +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the new remote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the url of the remote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Remote"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_remote" ggit_repository_create_remote :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- url : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Remote.Remote) + +{- | +Adds a remote with the default fetch refspec to the repository\'s configuration. +-} +repositoryCreateRemote :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the new remote. -} + -> T.Text + {- ^ /@url@/: the url of the remote. -} + -> m (Maybe Ggit.Remote.Remote) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.Remote.Remote' or 'Nothing' if there is an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateRemote repository name url = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + url' <- textToCString url + onException (do + result <- propagateGError $ ggit_repository_create_remote repository' name' url' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Remote.Remote) result' + return result'' + touchManagedPtr repository + freeMem name' + freeMem url' + return maybeResult + ) (do + freeMem name' + freeMem url' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateRemoteMethodInfo +instance (signature ~ (T.Text -> T.Text -> m (Maybe Ggit.Remote.Remote)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateRemoteMethodInfo a signature where + overloadedMethod _ = repositoryCreateRemote + +#endif + +-- method Repository::create_symbolic_reference +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name for the new #GgitRef.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the full name to the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "log_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The one line long message to be appended to the reflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_symbolic_reference" ggit_repository_create_symbolic_reference :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- target : TBasicType TUTF8 + CString -> -- log_message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Ref.Ref) + +{- | +Creates a new symbolic reference. + +The reference will be created in the repository and written +to the disk. The returned value must be freed with 'GI.GObject.Objects.Object.objectUnref'. +-} +repositoryCreateSymbolicReference :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name for the new 'GI.Ggit.Objects.Ref.Ref'. -} + -> T.Text + {- ^ /@target@/: the full name to the reference. -} + -> T.Text + {- ^ /@logMessage@/: The one line long message to be appended to the reflog. -} + -> m (Maybe Ggit.Ref.Ref) + {- ^ __Returns:__ the newly created reference. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateSymbolicReference repository name target logMessage = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + target' <- textToCString target + logMessage' <- textToCString logMessage + onException (do + result <- propagateGError $ ggit_repository_create_symbolic_reference repository' name' target' logMessage' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Ref.Ref) result' + return result'' + touchManagedPtr repository + freeMem name' + freeMem target' + freeMem logMessage' + return maybeResult + ) (do + freeMem name' + freeMem target' + freeMem logMessage' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateSymbolicReferenceMethodInfo +instance (signature ~ (T.Text -> T.Text -> T.Text -> m (Maybe Ggit.Ref.Ref)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateSymbolicReferenceMethodInfo a signature where + overloadedMethod _ = repositoryCreateSymbolicReference + +#endif + +-- method Repository::create_tag +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tagger", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "CreateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCreateFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_tag" ggit_repository_create_tag :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- tag_name : TBasicType TUTF8 + Ptr Ggit.Object.Object -> -- target : TInterface (Name {namespace = "Ggit", name = "Object"}) + Ptr Ggit.Signature.Signature -> -- tagger : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "CreateFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Create a new tag object. +-} +repositoryCreateTag :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.Signature.IsSignature c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@tagName@/: the tag name. -} + -> b + {- ^ /@target@/: a 'GI.Ggit.Objects.Object.Object'. -} + -> c + {- ^ /@tagger@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> T.Text + {- ^ /@message@/: the tag message. -} + -> [Ggit.Flags.CreateFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.CreateFlags'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the id to which the tag points, or + 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateTag repository tagName target tagger message flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + tagName' <- textToCString tagName + target' <- unsafeManagedPtrCastPtr target + tagger' <- unsafeManagedPtrCastPtr tagger + message' <- textToCString message + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ ggit_repository_create_tag repository' tagName' target' tagger' message' flags' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + touchManagedPtr target + touchManagedPtr tagger + freeMem tagName' + freeMem message' + return maybeResult + ) (do + freeMem tagName' + freeMem message' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateTagMethodInfo +instance (signature ~ (T.Text -> b -> c -> T.Text -> [Ggit.Flags.CreateFlags] -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.Signature.IsSignature c) => O.MethodInfo RepositoryCreateTagMethodInfo a signature where + overloadedMethod _ = repositoryCreateTag + +#endif + +-- method Repository::create_tag_annotation +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the tag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_tag_annotation" ggit_repository_create_tag_annotation :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- tag_name : TBasicType TUTF8 + Ptr Ggit.Object.Object -> -- target : TInterface (Name {namespace = "Ggit", name = "Object"}) + Ptr Ggit.Signature.Signature -> -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Creates a new annotated tag. +-} +repositoryCreateTagAnnotation :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.Signature.IsSignature c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@tagName@/: the name of the tag. -} + -> b + {- ^ /@target@/: a 'GI.Ggit.Objects.Object.Object'. -} + -> c + {- ^ /@signature@/: a 'GI.Ggit.Objects.Object.Object'. -} + -> T.Text + {- ^ /@message@/: the tag message. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the id to which the tag points, or + 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateTagAnnotation repository tagName target signature message = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + tagName' <- textToCString tagName + target' <- unsafeManagedPtrCastPtr target + signature' <- unsafeManagedPtrCastPtr signature + message' <- textToCString message + onException (do + result <- propagateGError $ ggit_repository_create_tag_annotation repository' tagName' target' signature' message' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + touchManagedPtr target + touchManagedPtr signature + freeMem tagName' + freeMem message' + return maybeResult + ) (do + freeMem tagName' + freeMem message' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateTagAnnotationMethodInfo +instance (signature ~ (T.Text -> b -> c -> T.Text -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.Signature.IsSignature c) => O.MethodInfo RepositoryCreateTagAnnotationMethodInfo a signature where + overloadedMethod _ = repositoryCreateTagAnnotation + +#endif + +-- method Repository::create_tag_from_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "CreateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCreateFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_tag_from_buffer" ggit_repository_create_tag_from_buffer :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- tag : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "CreateFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Create a new tag from a buffer describing the tag object. The buffer must +be correctly formatted. +-} +repositoryCreateTagFromBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@tag@/: the tag buffer. -} + -> [Ggit.Flags.CreateFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.CreateFlags'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the id to which the tag points, or + 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateTagFromBuffer repository tag flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + tag' <- textToCString tag + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ ggit_repository_create_tag_from_buffer repository' tag' flags' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + freeMem tag' + return maybeResult + ) (do + freeMem tag' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateTagFromBufferMethodInfo +instance (signature ~ (T.Text -> [Ggit.Flags.CreateFlags] -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateTagFromBufferMethodInfo a signature where + overloadedMethod _ = repositoryCreateTagFromBuffer + +#endif + +-- method Repository::create_tag_lightweight +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the tag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "CreateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCreateFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_tag_lightweight" ggit_repository_create_tag_lightweight :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- tag_name : TBasicType TUTF8 + Ptr Ggit.Object.Object -> -- target : TInterface (Name {namespace = "Ggit", name = "Object"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "CreateFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Creates a new lightweight tag. +-} +repositoryCreateTagLightweight :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Object.IsObject b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@tagName@/: the name of the tag. -} + -> b + {- ^ /@target@/: a 'GI.Ggit.Objects.Object.Object'. -} + -> [Ggit.Flags.CreateFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.CreateFlags'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the id to which the tag points, or + 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateTagLightweight repository tagName target flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + tagName' <- textToCString tagName + target' <- unsafeManagedPtrCastPtr target + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ ggit_repository_create_tag_lightweight repository' tagName' target' flags' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + touchManagedPtr target + freeMem tagName' + return maybeResult + ) (do + freeMem tagName' + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateTagLightweightMethodInfo +instance (signature ~ (T.Text -> b -> [Ggit.Flags.CreateFlags] -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a, Ggit.Object.IsObject b) => O.MethodInfo RepositoryCreateTagLightweightMethodInfo a signature where + overloadedMethod _ = repositoryCreateTagLightweight + +#endif + +-- method Repository::create_tree_builder +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeBuilder"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_tree_builder" ggit_repository_create_tree_builder :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.TreeBuilder.TreeBuilder) + +{- | +Create a new tree builder. +-} +repositoryCreateTreeBuilder :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Ggit.TreeBuilder.TreeBuilder) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.TreeBuilder.TreeBuilder', +or 'Nothing' if there was an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateTreeBuilder repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_repository_create_tree_builder repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.TreeBuilder.TreeBuilder) result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateTreeBuilderMethodInfo +instance (signature ~ (m (Maybe Ggit.TreeBuilder.TreeBuilder)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryCreateTreeBuilderMethodInfo a signature where + overloadedMethod _ = repositoryCreateTreeBuilder + +#endif + +-- method Repository::create_tree_builder_from_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeBuilder"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_create_tree_builder_from_tree" ggit_repository_create_tree_builder_from_tree :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Tree.Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.TreeBuilder.TreeBuilder) + +{- | +Create a tree builder for initialized with /@tree@/. To create an empty +tree builder, use @/ggit_repository_create_tree_builder/@ instead. +-} +repositoryCreateTreeBuilderFromTree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Tree.IsTree b) => + a + -> b + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> m (Maybe Ggit.TreeBuilder.TreeBuilder) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.TreeBuilder.TreeBuilder' object, +or 'Nothing' if there was an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryCreateTreeBuilderFromTree repository tree = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + tree' <- unsafeManagedPtrCastPtr tree + onException (do + result <- propagateGError $ ggit_repository_create_tree_builder_from_tree repository' tree' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.TreeBuilder.TreeBuilder) result' + return result'' + touchManagedPtr repository + touchManagedPtr tree + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryCreateTreeBuilderFromTreeMethodInfo +instance (signature ~ (b -> m (Maybe Ggit.TreeBuilder.TreeBuilder)), MonadIO m, IsRepository a, Ggit.Tree.IsTree b) => O.MethodInfo RepositoryCreateTreeBuilderFromTreeMethodInfo a signature where + overloadedMethod _ = repositoryCreateTreeBuilderFromTree + +#endif + +-- method Repository::delete_tag +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the tag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_delete_tag" ggit_repository_delete_tag :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Delete an existing tag reference by name. +-} +repositoryDeleteTag :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the tag. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryDeleteTag repository name = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + onException (do + _ <- propagateGError $ ggit_repository_delete_tag repository' name' + touchManagedPtr repository + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositoryDeleteTagMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryDeleteTagMethodInfo a signature where + overloadedMethod _ = repositoryDeleteTag + +#endif + +-- method Repository::drop_stash +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position within the stash list. 0 points to the.\nmost recent stashed state.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_drop_stash" ggit_repository_drop_stash :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Word64 -> -- index : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Removes a single stashed state from the stash list. +-} +repositoryDropStash :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Word64 + {- ^ /@index@/: the position within the stash list. 0 points to the. +most recent stashed state. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryDropStash repository index = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + propagateGError $ ggit_repository_drop_stash repository' index + touchManagedPtr repository + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryDropStashMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryDropStashMethodInfo a signature where + overloadedMethod _ = repositoryDropStash + +#endif + +-- method Repository::enumerate_branches +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list_type", argType = TInterface (Name {namespace = "Ggit", name = "BranchType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranchType.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_enumerate_branches" ggit_repository_enumerate_branches :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CUInt -> -- list_type : TInterface (Name {namespace = "Ggit", name = "BranchType"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.BranchEnumerator.BranchEnumerator) + +{- | +Get a branch enumerator to enumerate over all branches of the specified +/@listType@/ in /@repository@/. +-} +repositoryEnumerateBranches :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.Enums.BranchType + {- ^ /@listType@/: a 'GI.Ggit.Enums.BranchType'. -} + -> m (Maybe Ggit.BranchEnumerator.BranchEnumerator) + {- ^ __Returns:__ a branch enumerator. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryEnumerateBranches repository listType = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + let listType' = (fromIntegral . fromEnum) listType + onException (do + result <- propagateGError $ ggit_repository_enumerate_branches repository' listType' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.BranchEnumerator.BranchEnumerator) result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryEnumerateBranchesMethodInfo +instance (signature ~ (Ggit.Enums.BranchType -> m (Maybe Ggit.BranchEnumerator.BranchEnumerator)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryEnumerateBranchesMethodInfo a signature where + overloadedMethod _ = repositoryEnumerateBranches + +#endif + +-- method Repository::file_status +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file to retrieve status for, rooted at the repository working dir.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "StatusFlags"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_file_status" ggit_repository_file_status :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Gio.File.File -> -- location : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO CUInt + +{- | +Gets the file status for a single file. +-} +repositoryFileStatus :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Gio.File.IsFile b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@location@/: the file to retrieve status for, rooted at the repository working dir. -} + -> m [Ggit.Flags.StatusFlags] + {- ^ __Returns:__ the status for a single file. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryFileStatus repository location = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + location' <- unsafeManagedPtrCastPtr location + onException (do + result <- propagateGError $ ggit_repository_file_status repository' location' + let result' = wordToGFlags result + touchManagedPtr repository + touchManagedPtr location + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryFileStatusMethodInfo +instance (signature ~ (b -> m [Ggit.Flags.StatusFlags]), MonadIO m, IsRepository a, Gio.File.IsFile b) => O.MethodInfo RepositoryFileStatusMethodInfo a signature where + overloadedMethod _ = repositoryFileStatus + +#endif + +-- method Repository::file_status_foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "StatusOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "status options, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "StatusCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitStatusCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_file_status_foreach" ggit_repository_file_status_foreach :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.StatusOptions.StatusOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "StatusOptions"}) + FunPtr Ggit.Callbacks.C_StatusCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "StatusCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Gathers file statuses and run a callback for each one. + +To the callback is passed the path of the file, the status and the data pointer +passed to this function. If the callback returns something other than +0, the iteration will stop and /@error@/ will be set. + +Set /@options@/ to 'Nothing' to get the default status options. +-} +repositoryFileStatusForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (Ggit.StatusOptions.StatusOptions) + {- ^ /@options@/: status options, or 'Nothing'. -} + -> Ggit.Callbacks.StatusCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.StatusCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryFileStatusForeach repository options callback = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrGetPtr jOptions + return jOptions' + callback' <- Ggit.Callbacks.mk_StatusCallback (Ggit.Callbacks.wrap_StatusCallback Nothing (Ggit.Callbacks.drop_closures_StatusCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_repository_file_status_foreach repository' maybeOptions callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr repository + whenJust options touchManagedPtr + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryFileStatusForeachMethodInfo +instance (signature ~ (Maybe (Ggit.StatusOptions.StatusOptions) -> Ggit.Callbacks.StatusCallback -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryFileStatusForeachMethodInfo a signature where + overloadedMethod _ = repositoryFileStatusForeach + +#endif + +-- method Repository::get_ahead_behind +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "local", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the commit for local.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "upstream", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the commit for upstream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ahead", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of unique from commits in @upstream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "behind", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of unique from commits in @local.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_ahead_behind" ggit_repository_get_ahead_behind :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.OId.OId -> -- local : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr Ggit.OId.OId -> -- upstream : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr Word64 -> -- ahead : TBasicType TUInt64 + Ptr Word64 -> -- behind : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Count the number of unique commits between two commit objects. + +There is no need for branches containing the commits to have any +upstream relationship, but it helps to think of one as a branch and +the other as its upstream, the /@ahead@/ and /@behind@/ values will be +what git would report for the branches. +-} +repositoryGetAheadBehind :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.OId.OId + {- ^ /@local@/: the commit for local. -} + -> Ggit.OId.OId + {- ^ /@upstream@/: the commit for upstream. -} + -> m ((Word64, Word64)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetAheadBehind repository local upstream = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + local' <- unsafeManagedPtrGetPtr local + upstream' <- unsafeManagedPtrGetPtr upstream + ahead <- allocMem :: IO (Ptr Word64) + behind <- allocMem :: IO (Ptr Word64) + onException (do + propagateGError $ ggit_repository_get_ahead_behind repository' local' upstream' ahead behind + ahead' <- peek ahead + behind' <- peek behind + touchManagedPtr repository + touchManagedPtr local + touchManagedPtr upstream + freeMem ahead + freeMem behind + return (ahead', behind') + ) (do + freeMem ahead + freeMem behind + ) + +#if ENABLE_OVERLOADING +data RepositoryGetAheadBehindMethodInfo +instance (signature ~ (Ggit.OId.OId -> Ggit.OId.OId -> m ((Word64, Word64))), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetAheadBehindMethodInfo a signature where + overloadedMethod _ = repositoryGetAheadBehind + +#endif + +-- method Repository::get_attribute +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the relative path to the file.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the attribute.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "AttributeCheckFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitAttributeCheckFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_attribute" ggit_repository_get_attribute :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- path : TBasicType TUTF8 + CString -> -- name : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "AttributeCheckFlags"}) + Ptr (Ptr GError) -> -- error + IO CString + +{- | +Get the attribute value of the specified attribute for the given file. +-} +repositoryGetAttribute :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@path@/: the relative path to the file. -} + -> T.Text + {- ^ /@name@/: the name of the attribute. -} + -> [Ggit.Flags.AttributeCheckFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.AttributeCheckFlags'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the attribute value, or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetAttribute repository path name flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + path' <- textToCString path + name' <- textToCString name + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ ggit_repository_get_attribute repository' path' name' flags' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr repository + freeMem path' + freeMem name' + return maybeResult + ) (do + freeMem path' + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositoryGetAttributeMethodInfo +instance (signature ~ (T.Text -> T.Text -> [Ggit.Flags.AttributeCheckFlags] -> m (Maybe T.Text)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetAttributeMethodInfo a signature where + overloadedMethod _ = repositoryGetAttribute + +#endif + +-- method Repository::get_config +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Config"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_config" ggit_repository_get_config :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Config.Config) + +{- | +Get the config for a specific repository. +-} +repositoryGetConfig :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Ggit.Config.Config) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Config.Config'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetConfig repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_repository_get_config repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Config.Config) result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryGetConfigMethodInfo +instance (signature ~ (m (Maybe Ggit.Config.Config)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetConfigMethodInfo a signature where + overloadedMethod _ = repositoryGetConfig + +#endif + +-- method Repository::get_default_notes_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_default_notes_ref" ggit_repository_get_default_notes_ref :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO CString + +{- | +Gets the default notes reference for /@repository@/. It defaults to +\"refs\/notes\/commits\". +-} +repositoryGetDefaultNotesRef :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the default notes reference for /@repository@/. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetDefaultNotesRef repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_repository_get_default_notes_ref repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryGetDefaultNotesRefMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetDefaultNotesRefMethodInfo a signature where + overloadedMethod _ = repositoryGetDefaultNotesRef + +#endif + +-- method Repository::get_descendant_of +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the commit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the ancestor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_descendant_of" ggit_repository_get_descendant_of :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.OId.OId -> -- commit : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr Ggit.OId.OId -> -- ancestor : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Check whether /@com@/ mit is a descendant of /@ancestor@/. Note that if this +function returns 'False', an error might have occurred. If so, /@error@/ will +be set appropriately. +-} +repositoryGetDescendantOf :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.OId.OId + {- ^ /@commit@/: the commit. -} + -> Ggit.OId.OId + {- ^ /@ancestor@/: the ancestor. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetDescendantOf repository commit ancestor = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + commit' <- unsafeManagedPtrGetPtr commit + ancestor' <- unsafeManagedPtrGetPtr ancestor + onException (do + _ <- propagateGError $ ggit_repository_get_descendant_of repository' commit' ancestor' + touchManagedPtr repository + touchManagedPtr commit + touchManagedPtr ancestor + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryGetDescendantOfMethodInfo +instance (signature ~ (Ggit.OId.OId -> Ggit.OId.OId -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetDescendantOfMethodInfo a signature where + overloadedMethod _ = repositoryGetDescendantOf + +#endif + +-- method Repository::get_head +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_head" ggit_repository_get_head :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Ref.Ref) + +{- | +Get and resolves the current HEAD reference of the repository. Note that the +returned ref is already resolved (if HEAD is symbolic). If you want to +retrieve the symbolic ref called HEAD, then use @/ggit_repository_lookup_reference/@ +instead. +-} +repositoryGetHead :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Ggit.Ref.Ref) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Ref.Ref' /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetHead repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_repository_get_head repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Ref.Ref) result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryGetHeadMethodInfo +instance (signature ~ (m (Maybe Ggit.Ref.Ref)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetHeadMethodInfo a signature where + overloadedMethod _ = repositoryGetHead + +#endif + +-- method Repository::get_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Index"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_index" ggit_repository_get_index :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Index.Index) + +{- | +Get the index for a specific repository. +-} +repositoryGetIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Ggit.Index.Index) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Index.Index'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetIndex repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_repository_get_index repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Index.Index) result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryGetIndexMethodInfo +instance (signature ~ (m (Maybe Ggit.Index.Index)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetIndexMethodInfo a signature where + overloadedMethod _ = repositoryGetIndex + +#endif + +-- method Repository::get_location +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_repository_get_location" ggit_repository_get_location :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + IO (Ptr Gio.File.File) + +{- | +Get the gitdir location of the repository. +-} +repositoryGetLocation :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Gio.File.File) + {- ^ __Returns:__ the location of the gitdir of the repository. -} +repositoryGetLocation repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + result <- ggit_repository_get_location repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Gio.File.File) result' + return result'' + touchManagedPtr repository + return maybeResult + +#if ENABLE_OVERLOADING +data RepositoryGetLocationMethodInfo +instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetLocationMethodInfo a signature where + overloadedMethod _ = repositoryGetLocation + +#endif + +-- method Repository::get_submodule_status +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ignore", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleIgnore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the ignore rules to follow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "SubmoduleStatus"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_get_submodule_status" ggit_repository_get_submodule_status :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CInt -> -- ignore : TInterface (Name {namespace = "Ggit", name = "SubmoduleIgnore"}) + Ptr (Ptr GError) -> -- error + IO CUInt + +{- | +Gets the status for a submodule. +This looks at a submodule and tries to determine the status. It +will return a combination of the @/GGIT_SUBMODULE_STATUS/@ values. +How deeply it examines the working directory to do this will depend +on /@ignore@/. +-} +repositoryGetSubmoduleStatus :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> Ggit.Enums.SubmoduleIgnore + {- ^ /@ignore@/: the ignore rules to follow. -} + -> m [Ggit.Flags.SubmoduleStatus] + {- ^ __Returns:__ the 'GI.Ggit.Flags.SubmoduleStatus' for /@submodule@/. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryGetSubmoduleStatus repository name ignore = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + let ignore' = (fromIntegral . fromEnum) ignore + onException (do + result <- propagateGError $ ggit_repository_get_submodule_status repository' name' ignore' + let result' = wordToGFlags result + touchManagedPtr repository + freeMem name' + return result' + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositoryGetSubmoduleStatusMethodInfo +instance (signature ~ (T.Text -> Ggit.Enums.SubmoduleIgnore -> m [Ggit.Flags.SubmoduleStatus]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetSubmoduleStatusMethodInfo a signature where + overloadedMethod _ = repositoryGetSubmoduleStatus + +#endif + +-- method Repository::get_workdir +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_repository_get_workdir" ggit_repository_get_workdir :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + IO (Ptr Gio.File.File) + +{- | +Gets the working directory of the repository. +-} +repositoryGetWorkdir :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Gio.File.File) + {- ^ __Returns:__ the location of the working directory of the repository. -} +repositoryGetWorkdir repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + result <- ggit_repository_get_workdir repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Gio.File.File) result' + return result'' + touchManagedPtr repository + return maybeResult + +#if ENABLE_OVERLOADING +data RepositoryGetWorkdirMethodInfo +instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetWorkdirMethodInfo a signature where + overloadedMethod _ = repositoryGetWorkdir + +#endif + +-- method Repository::is_bare +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_repository_is_bare" ggit_repository_is_bare :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + IO CInt + +{- | +Checks if /@repository@/ is bare. +-} +repositoryIsBare :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the repository is empty. -} +repositoryIsBare repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + result <- ggit_repository_is_bare repository' + let result' = (/= 0) result + touchManagedPtr repository + return result' + +#if ENABLE_OVERLOADING +data RepositoryIsBareMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRepository a) => O.MethodInfo RepositoryIsBareMethodInfo a signature where + overloadedMethod _ = repositoryIsBare + +#endif + +-- method Repository::is_empty +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_is_empty" ggit_repository_is_empty :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Checks if /@repository@/ is empty. + +An empty repository has just been initialized and contains +no commits. +-} +repositoryIsEmpty :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryIsEmpty repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + _ <- propagateGError $ ggit_repository_is_empty repository' + touchManagedPtr repository + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryIsEmptyMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryIsEmptyMethodInfo a signature where + overloadedMethod _ = repositoryIsEmpty + +#endif + +-- method Repository::is_head_detached +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_is_head_detached" ggit_repository_is_head_detached :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Checks if /@repository@/\'s HEAD is detached. + +A repository\'s HEAD is detached when it points directly to a commit +instead of a branch. +-} +repositoryIsHeadDetached :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryIsHeadDetached repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + _ <- propagateGError $ ggit_repository_is_head_detached repository' + touchManagedPtr repository + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryIsHeadDetachedMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryIsHeadDetachedMethodInfo a signature where + overloadedMethod _ = repositoryIsHeadDetached + +#endif + +-- method Repository::is_head_unborn +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_is_head_unborn" ggit_repository_is_head_unborn :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Checks if /@repository@/\'s HEAD is an orphan. + +An orphan branch is one named from HEAD but doesn\'t exist in +the refs namespace, because it doesn\'t have any commit to point to. +-} +repositoryIsHeadUnborn :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryIsHeadUnborn repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + _ <- propagateGError $ ggit_repository_is_head_unborn repository' + touchManagedPtr repository + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryIsHeadUnbornMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryIsHeadUnbornMethodInfo a signature where + overloadedMethod _ = repositoryIsHeadUnborn + +#endif + +-- method Repository::list_remotes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_list_remotes" ggit_repository_list_remotes :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr CString) + +{- | +Fill a list with all the remotes in /@repository@/. +-} +repositoryListRemotes :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a list with the remotes. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryListRemotes repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_repository_list_remotes repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryListRemotesMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsRepository a) => O.MethodInfo RepositoryListRemotesMethodInfo a signature where + overloadedMethod _ = repositoryListRemotes + +#endif + +-- method Repository::list_tags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_list_tags" ggit_repository_list_tags :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr CString) + +{- | +Fill a list with all the tags in the /@repository@/. +-} +repositoryListTags :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a list with the tags in /@repository@/. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryListTags repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_repository_list_tags repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryListTagsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsRepository a) => O.MethodInfo RepositoryListTagsMethodInfo a signature where + overloadedMethod _ = repositoryListTags + +#endif + +-- method Repository::list_tags_match +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a pattern to match.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_list_tags_match" ggit_repository_list_tags_match :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- pattern : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr CString) + +{- | +Fill a list with all the tags in the /@repository@/ matching the provided +pattern. The pattern can use standard fnmatch syntax. +-} +repositoryListTagsMatch :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@pattern@/: a pattern to match. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a list with matching tags in /@repository@/. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryListTagsMatch repository pattern = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybePattern <- case pattern of + Nothing -> return nullPtr + Just jPattern -> do + jPattern' <- textToCString jPattern + return jPattern' + onException (do + result <- propagateGError $ ggit_repository_list_tags_match repository' maybePattern + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr repository + freeMem maybePattern + return maybeResult + ) (do + freeMem maybePattern + ) + +#if ENABLE_OVERLOADING +data RepositoryListTagsMatchMethodInfo +instance (signature ~ (Maybe (T.Text) -> m (Maybe [T.Text])), MonadIO m, IsRepository a) => O.MethodInfo RepositoryListTagsMatchMethodInfo a signature where + overloadedMethod _ = repositoryListTagsMatch + +#endif + +-- method Repository::lookup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GType.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Object"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup" ggit_repository_lookup :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + CGType -> -- gtype : TBasicType TGType + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Object.Object) + +{- | +Lookups a reference to one of the objects in the /@repository@/. + +The generated reference must be freed with 'GI.GObject.Objects.Object.objectUnref'. + +The /@gtype@/ must match the type of the object +in the odb; the method will fail otherwise. +The special value @/G_TYPE_NONE/@ may be passed to let +the method guess the object\'s type. +-} +repositoryLookup :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> GType + {- ^ /@gtype@/: a 'GType'. -} + -> m (Maybe Ggit.Object.Object) + {- ^ __Returns:__ the found 'GI.Ggit.Objects.Object.Object', or 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookup repository oid gtype = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + oid' <- unsafeManagedPtrGetPtr oid + let gtype' = gtypeToCGType gtype + onException (do + result <- propagateGError $ ggit_repository_lookup repository' oid' gtype' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Object.Object) result' + return result'' + touchManagedPtr repository + touchManagedPtr oid + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupMethodInfo +instance (signature ~ (Ggit.OId.OId -> GType -> m (Maybe Ggit.Object.Object)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupMethodInfo a signature where + overloadedMethod _ = repositoryLookup + +#endif + +-- method Repository::lookup_blob +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Blob"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_blob" ggit_repository_lookup_blob :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Blob.Blob) + +{- | +Lookups a branch by its name in a repository. +-} +repositoryLookupBlob :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe Ggit.Blob.Blob) + {- ^ __Returns:__ a @/GgitBlog/@ pointer. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupBlob repository oid = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + oid' <- unsafeManagedPtrGetPtr oid + onException (do + result <- propagateGError $ ggit_repository_lookup_blob repository' oid' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Blob.Blob) result' + return result'' + touchManagedPtr repository + touchManagedPtr oid + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupBlobMethodInfo +instance (signature ~ (Ggit.OId.OId -> m (Maybe Ggit.Blob.Blob)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupBlobMethodInfo a signature where + overloadedMethod _ = repositoryLookupBlob + +#endif + +-- method Repository::lookup_branch +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "branch_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the branch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "branch_type", argType = TInterface (Name {namespace = "Ggit", name = "BranchType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranchType.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Branch"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_branch" ggit_repository_lookup_branch :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- branch_name : TBasicType TUTF8 + CUInt -> -- branch_type : TInterface (Name {namespace = "Ggit", name = "BranchType"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Branch.Branch) + +{- | +Lookups a branch by its name in a repository. +-} +repositoryLookupBranch :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@branchName@/: the name of the branch. -} + -> Ggit.Enums.BranchType + {- ^ /@branchType@/: a 'GI.Ggit.Enums.BranchType'. -} + -> m (Maybe Ggit.Branch.Branch) + {- ^ __Returns:__ a branch by its name in a repository. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupBranch repository branchName branchType = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + branchName' <- textToCString branchName + let branchType' = (fromIntegral . fromEnum) branchType + onException (do + result <- propagateGError $ ggit_repository_lookup_branch repository' branchName' branchType' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Branch.Branch) result' + return result'' + touchManagedPtr repository + freeMem branchName' + return maybeResult + ) (do + freeMem branchName' + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupBranchMethodInfo +instance (signature ~ (T.Text -> Ggit.Enums.BranchType -> m (Maybe Ggit.Branch.Branch)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupBranchMethodInfo a signature where + overloadedMethod _ = repositoryLookupBranch + +#endif + +-- method Repository::lookup_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Commit"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_commit" ggit_repository_lookup_commit :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Commit.Commit) + +{- | +Lookups a branch by its name in a repository. +-} +repositoryLookupCommit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe Ggit.Commit.Commit) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Commit.Commit' pointer. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupCommit repository oid = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + oid' <- unsafeManagedPtrGetPtr oid + onException (do + result <- propagateGError $ ggit_repository_lookup_commit repository' oid' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Commit.Commit) result' + return result'' + touchManagedPtr repository + touchManagedPtr oid + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupCommitMethodInfo +instance (signature ~ (Ggit.OId.OId -> m (Maybe Ggit.Commit.Commit)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupCommitMethodInfo a signature where + overloadedMethod _ = repositoryLookupCommit + +#endif + +-- method Repository::lookup_reference +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the long name for the reference (e.g. HEAD, ref/heads/master, refs/tags/v0.1.0, ...).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_reference" ggit_repository_lookup_reference :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Ref.Ref) + +{- | +Lookups a reference by its name in /@repository@/. The returned 'GI.Ggit.Objects.Ref.Ref' must +be freed with 'GI.GObject.Objects.Object.objectUnref'. +-} +repositoryLookupReference :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the long name for the reference (e.g. HEAD, ref\/heads\/master, refs\/tags\/v0.1.0, ...). -} + -> m (Maybe Ggit.Ref.Ref) + {- ^ __Returns:__ the searched reference. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupReference repository name = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + onException (do + result <- propagateGError $ ggit_repository_lookup_reference repository' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Ref.Ref) result' + return result'' + touchManagedPtr repository + freeMem name' + return maybeResult + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupReferenceMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.Ref.Ref)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupReferenceMethodInfo a signature where + overloadedMethod _ = repositoryLookupReference + +#endif + +-- method Repository::lookup_reference_dwim +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "short_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the short name for the reference (e.g. master, v0.1.0, ...).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_reference_dwim" ggit_repository_lookup_reference_dwim :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- short_name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Ref.Ref) + +{- | +Lookups a reference by its short name in /@repository@/ applying the git precendence +rules to the given shorthand to determine which reference the user is referring to. +The returned 'GI.Ggit.Objects.Ref.Ref' must be freed with 'GI.GObject.Objects.Object.objectUnref'. +-} +repositoryLookupReferenceDwim :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@shortName@/: the short name for the reference (e.g. master, v0.1.0, ...). -} + -> m (Maybe Ggit.Ref.Ref) + {- ^ __Returns:__ the searched reference. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupReferenceDwim repository shortName = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + shortName' <- textToCString shortName + onException (do + result <- propagateGError $ ggit_repository_lookup_reference_dwim repository' shortName' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Ref.Ref) result' + return result'' + touchManagedPtr repository + freeMem shortName' + return maybeResult + ) (do + freeMem shortName' + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupReferenceDwimMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.Ref.Ref)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupReferenceDwimMethodInfo a signature where + overloadedMethod _ = repositoryLookupReferenceDwim + +#endif + +-- method Repository::lookup_remote +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the remote's name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Remote"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_remote" ggit_repository_lookup_remote :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Remote.Remote) + +{- | +Gets the remote called /@name@/. +-} +repositoryLookupRemote :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the remote\'s name. -} + -> m (Maybe Ggit.Remote.Remote) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.Remote.Remote' or 'Nothing' if there is an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupRemote repository name = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + onException (do + result <- propagateGError $ ggit_repository_lookup_remote repository' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Remote.Remote) result' + return result'' + touchManagedPtr repository + freeMem name' + return maybeResult + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupRemoteMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.Remote.Remote)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupRemoteMethodInfo a signature where + overloadedMethod _ = repositoryLookupRemote + +#endif + +-- method Repository::lookup_submodule +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Submodule"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_submodule" ggit_repository_lookup_submodule :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Submodule.Submodule) + +{- | +Lookups a submodule information by name or path. If the submodule +does not exist, 'Nothing' is returned and a GGIT_ERROR_NOTFOUND error set. +-} +repositoryLookupSubmodule :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> m (Maybe Ggit.Submodule.Submodule) + {- ^ __Returns:__ a newly-allocated 'GI.Ggit.Structs.Submodule.Submodule'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupSubmodule repository name = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + onException (do + result <- propagateGError $ ggit_repository_lookup_submodule repository' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.Submodule.Submodule) result' + return result'' + touchManagedPtr repository + freeMem name' + return maybeResult + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupSubmoduleMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.Submodule.Submodule)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupSubmoduleMethodInfo a signature where + overloadedMethod _ = repositoryLookupSubmodule + +#endif + +-- method Repository::lookup_tag +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Tag"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_tag" ggit_repository_lookup_tag :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Tag.Tag) + +{- | +Lookups a branch by its name in a repository. +-} +repositoryLookupTag :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe Ggit.Tag.Tag) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Tag.Tag' pointer. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupTag repository oid = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + oid' <- unsafeManagedPtrGetPtr oid + onException (do + result <- propagateGError $ ggit_repository_lookup_tag repository' oid' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Tag.Tag) result' + return result'' + touchManagedPtr repository + touchManagedPtr oid + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupTagMethodInfo +instance (signature ~ (Ggit.OId.OId -> m (Maybe Ggit.Tag.Tag)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupTagMethodInfo a signature where + overloadedMethod _ = repositoryLookupTag + +#endif + +-- method Repository::lookup_tree +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Tree"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_lookup_tree" ggit_repository_lookup_tree :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Tree.Tree) + +{- | +Lookups a branch by its name in a repository. +-} +repositoryLookupTree :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe Ggit.Tree.Tree) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Tree.Tree' pointer. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLookupTree repository oid = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + oid' <- unsafeManagedPtrGetPtr oid + onException (do + result <- propagateGError $ ggit_repository_lookup_tree repository' oid' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Tree.Tree) result' + return result'' + touchManagedPtr repository + touchManagedPtr oid + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryLookupTreeMethodInfo +instance (signature ~ (Ggit.OId.OId -> m (Maybe Ggit.Tree.Tree)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLookupTreeMethodInfo a signature where + overloadedMethod _ = repositoryLookupTree + +#endif + +-- method Repository::merge_commits +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "our_commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the commit that reflects the destination tree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "their_commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the commit that reflects the source tree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the merge options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Index"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_merge_commits" ggit_repository_merge_commits :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Commit.Commit -> -- our_commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + Ptr Ggit.Commit.Commit -> -- their_commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + Ptr Ggit.MergeOptions.MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Index.Index) + +{- | +Merge two commits creating a 'GI.Ggit.Objects.Index.Index' reflecting the result of the merge. +-} +repositoryMergeCommits :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Commit.IsCommit b, Ggit.Commit.IsCommit c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@ourCommit@/: the commit that reflects the destination tree. -} + -> c + {- ^ /@theirCommit@/: the commit that reflects the source tree. -} + -> Ggit.MergeOptions.MergeOptions + {- ^ /@mergeOptions@/: the merge options. -} + -> m (Maybe Ggit.Index.Index) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.Index.Index' or 'Nothing' if an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryMergeCommits repository ourCommit theirCommit mergeOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + ourCommit' <- unsafeManagedPtrCastPtr ourCommit + theirCommit' <- unsafeManagedPtrCastPtr theirCommit + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + onException (do + result <- propagateGError $ ggit_repository_merge_commits repository' ourCommit' theirCommit' mergeOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Index.Index) result' + return result'' + touchManagedPtr repository + touchManagedPtr ourCommit + touchManagedPtr theirCommit + touchManagedPtr mergeOptions + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryMergeCommitsMethodInfo +instance (signature ~ (b -> c -> Ggit.MergeOptions.MergeOptions -> m (Maybe Ggit.Index.Index)), MonadIO m, IsRepository a, Ggit.Commit.IsCommit b, Ggit.Commit.IsCommit c) => O.MethodInfo RepositoryMergeCommitsMethodInfo a signature where + overloadedMethod _ = repositoryMergeCommits + +#endif + +-- method Repository::merge_trees +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor_tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the common ancestor between the trees, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "our_tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tree that reflects the destination tree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "their_tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tree that reflects the source tree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the merge options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Index"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_merge_trees" ggit_repository_merge_trees :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Tree.Tree -> -- ancestor_tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr Ggit.Tree.Tree -> -- our_tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr Ggit.Tree.Tree -> -- their_tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Ptr Ggit.MergeOptions.MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Index.Index) + +{- | +Merge two trees creating a 'GI.Ggit.Objects.Index.Index' reflecting the result of the merge. +-} +repositoryMergeTrees :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Tree.IsTree b, Ggit.Tree.IsTree c, Ggit.Tree.IsTree d) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@ancestorTree@/: the common ancestor between the trees, or 'Nothing'. -} + -> c + {- ^ /@ourTree@/: the tree that reflects the destination tree. -} + -> d + {- ^ /@theirTree@/: the tree that reflects the source tree. -} + -> Ggit.MergeOptions.MergeOptions + {- ^ /@mergeOptions@/: the merge options. -} + -> m (Maybe Ggit.Index.Index) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.Index.Index' or 'Nothing' if an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryMergeTrees repository ancestorTree ourTree theirTree mergeOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + ancestorTree' <- unsafeManagedPtrCastPtr ancestorTree + ourTree' <- unsafeManagedPtrCastPtr ourTree + theirTree' <- unsafeManagedPtrCastPtr theirTree + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + onException (do + result <- propagateGError $ ggit_repository_merge_trees repository' ancestorTree' ourTree' theirTree' mergeOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Index.Index) result' + return result'' + touchManagedPtr repository + touchManagedPtr ancestorTree + touchManagedPtr ourTree + touchManagedPtr theirTree + touchManagedPtr mergeOptions + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryMergeTreesMethodInfo +instance (signature ~ (b -> c -> d -> Ggit.MergeOptions.MergeOptions -> m (Maybe Ggit.Index.Index)), MonadIO m, IsRepository a, Ggit.Tree.IsTree b, Ggit.Tree.IsTree c, Ggit.Tree.IsTree d) => O.MethodInfo RepositoryMergeTreesMethodInfo a signature where + overloadedMethod _ = repositoryMergeTrees + +#endif + +-- method Repository::note_foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notes_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "canonical name of the reference to use, or %NULL to use the default ref.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "NoteCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitNoteCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_note_foreach" ggit_repository_note_foreach :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- notes_ref : TBasicType TUTF8 + FunPtr Ggit.Callbacks.C_NoteCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "NoteCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Loop over all the notes within a specified namespace +and issue a callback for each one. +If /@callback@/ returns a non-zero value, this will stop looping. +-} +repositoryNoteForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@notesRef@/: canonical name of the reference to use, or 'Nothing' to use the default ref. -} + -> Ggit.Callbacks.NoteCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.NoteCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryNoteForeach repository notesRef callback = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeNotesRef <- case notesRef of + Nothing -> return nullPtr + Just jNotesRef -> do + jNotesRef' <- textToCString jNotesRef + return jNotesRef' + callback' <- Ggit.Callbacks.mk_NoteCallback (Ggit.Callbacks.wrap_NoteCallback Nothing (Ggit.Callbacks.drop_closures_NoteCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_repository_note_foreach repository' maybeNotesRef callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr repository + freeMem maybeNotesRef + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + freeMem maybeNotesRef + ) + +#if ENABLE_OVERLOADING +data RepositoryNoteForeachMethodInfo +instance (signature ~ (Maybe (T.Text) -> Ggit.Callbacks.NoteCallback -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryNoteForeachMethodInfo a signature where + overloadedMethod _ = repositoryNoteForeach + +#endif + +-- method Repository::path_is_ignored +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A path within the repository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_path_is_ignored" ggit_repository_path_is_ignored :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- path : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Tests if the ignore rules apply to the path provided. + +This acts similar to filtering performed when calling \"git add .\" +on the command line. +-} +repositoryPathIsIgnored :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@path@/: A path within the repository. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryPathIsIgnored repository path = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + path' <- textToCString path + onException (do + _ <- propagateGError $ ggit_repository_path_is_ignored repository' path' + touchManagedPtr repository + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data RepositoryPathIsIgnoredMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryPathIsIgnoredMethodInfo a signature where + overloadedMethod _ = repositoryPathIsIgnored + +#endif + +-- method Repository::read_note +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notes_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "canonical name of the reference to use, or %NULL to use the default ref.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "OID of the git object to decorate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Note"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_read_note" ggit_repository_read_note :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- notes_ref : TBasicType TUTF8 + Ptr Ggit.OId.OId -> -- id : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Note.Note) + +{- | +Reads the note for an object. +-} +repositoryReadNote :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@notesRef@/: canonical name of the reference to use, or 'Nothing' to use the default ref. -} + -> Ggit.OId.OId + {- ^ /@id@/: OID of the git object to decorate. -} + -> m (Maybe Ggit.Note.Note) + {- ^ __Returns:__ the read note or 'Nothing' in case of an error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryReadNote repository notesRef id = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeNotesRef <- case notesRef of + Nothing -> return nullPtr + Just jNotesRef -> do + jNotesRef' <- textToCString jNotesRef + return jNotesRef' + id' <- unsafeManagedPtrGetPtr id + onException (do + result <- propagateGError $ ggit_repository_read_note repository' maybeNotesRef id' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.Note.Note) result' + return result'' + touchManagedPtr repository + touchManagedPtr id + freeMem maybeNotesRef + return maybeResult + ) (do + freeMem maybeNotesRef + ) + +#if ENABLE_OVERLOADING +data RepositoryReadNoteMethodInfo +instance (signature ~ (Maybe (T.Text) -> Ggit.OId.OId -> m (Maybe Ggit.Note.Note)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryReadNoteMethodInfo a signature where + overloadedMethod _ = repositoryReadNote + +#endif + +-- method Repository::rebase_init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "branch", argType = TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the terminal commit to rebase, or %NULL to rebase the\ncurrent branch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "upstream", argType = TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the commit to begin rebasing from, or %NULL to\nrebase all reachable commits.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "onto", argType = TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the branch to rebase onto, or %NULL to rebase onto\nthe given upstream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions to specify how rebase is performed, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Rebase"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_rebase_init" ggit_repository_rebase_init :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.AnnotatedCommit.AnnotatedCommit -> -- branch : TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}) + Ptr Ggit.AnnotatedCommit.AnnotatedCommit -> -- upstream : TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}) + Ptr Ggit.AnnotatedCommit.AnnotatedCommit -> -- onto : TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}) + Ptr Ggit.RebaseOptions.RebaseOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Rebase.Rebase) + +{- | +Initializes a rebase operation to rebase the changes in /@branch@/ +relative to /@upstream@/ onto another branch. To begin the rebase +process, call @/git_rebase_next()/@. When you have finished with this +object, call 'GI.GObject.Objects.Object.objectUnref'. +-} +repositoryRebaseInit :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (Ggit.AnnotatedCommit.AnnotatedCommit) + {- ^ /@branch@/: the terminal commit to rebase, or 'Nothing' to rebase the +current branch. -} + -> Maybe (Ggit.AnnotatedCommit.AnnotatedCommit) + {- ^ /@upstream@/: the commit to begin rebasing from, or 'Nothing' to +rebase all reachable commits. -} + -> Maybe (Ggit.AnnotatedCommit.AnnotatedCommit) + {- ^ /@onto@/: the branch to rebase onto, or 'Nothing' to rebase onto +the given upstream. -} + -> Ggit.RebaseOptions.RebaseOptions + {- ^ /@options@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions' to specify how rebase is performed, or 'Nothing'. -} + -> m (Maybe Ggit.Rebase.Rebase) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Rebase.Rebase'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryRebaseInit repository branch upstream onto options = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeBranch <- case branch of + Nothing -> return nullPtr + Just jBranch -> do + jBranch' <- unsafeManagedPtrGetPtr jBranch + return jBranch' + maybeUpstream <- case upstream of + Nothing -> return nullPtr + Just jUpstream -> do + jUpstream' <- unsafeManagedPtrGetPtr jUpstream + return jUpstream' + maybeOnto <- case onto of + Nothing -> return nullPtr + Just jOnto -> do + jOnto' <- unsafeManagedPtrGetPtr jOnto + return jOnto' + options' <- unsafeManagedPtrGetPtr options + onException (do + result <- propagateGError $ ggit_repository_rebase_init repository' maybeBranch maybeUpstream maybeOnto options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Rebase.Rebase) result' + return result'' + touchManagedPtr repository + whenJust branch touchManagedPtr + whenJust upstream touchManagedPtr + whenJust onto touchManagedPtr + touchManagedPtr options + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryRebaseInitMethodInfo +instance (signature ~ (Maybe (Ggit.AnnotatedCommit.AnnotatedCommit) -> Maybe (Ggit.AnnotatedCommit.AnnotatedCommit) -> Maybe (Ggit.AnnotatedCommit.AnnotatedCommit) -> Ggit.RebaseOptions.RebaseOptions -> m (Maybe Ggit.Rebase.Rebase)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryRebaseInitMethodInfo a signature where + overloadedMethod _ = repositoryRebaseInit + +#endif + +-- method Repository::rebase_open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions to specify how rebase is performed, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Rebase"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_rebase_open" ggit_repository_rebase_open :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.RebaseOptions.RebaseOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Rebase.Rebase) + +{- | +Opens an existing rebase that was previously started by either an +invocation of @/ggit_rebase_init()/@ or by another client. +-} +repositoryRebaseOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.RebaseOptions.RebaseOptions + {- ^ /@options@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions' to specify how rebase is performed, or 'Nothing'. -} + -> m (Maybe Ggit.Rebase.Rebase) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Rebase.Rebase'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryRebaseOpen repository options = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + options' <- unsafeManagedPtrGetPtr options + onException (do + result <- propagateGError $ ggit_repository_rebase_open repository' options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Rebase.Rebase) result' + return result'' + touchManagedPtr repository + touchManagedPtr options + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryRebaseOpenMethodInfo +instance (signature ~ (Ggit.RebaseOptions.RebaseOptions -> m (Maybe Ggit.Rebase.Rebase)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryRebaseOpenMethodInfo a signature where + overloadedMethod _ = repositoryRebaseOpen + +#endif + +-- method Repository::references_foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "ReferencesCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReferencesCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_references_foreach" ggit_repository_references_foreach :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + FunPtr Ggit.Callbacks.C_ReferencesCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "ReferencesCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Gathers references and run a callback for each one. + +To the callback is passed the reference and the data pointer +passed to this function. If the callback returns something other than +0, the iteration will stop and /@error@/ will be set. +-} +repositoryReferencesForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.Callbacks.ReferencesCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.ReferencesCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryReferencesForeach repository callback = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + callback' <- Ggit.Callbacks.mk_ReferencesCallback (Ggit.Callbacks.wrap_ReferencesCallback Nothing (Ggit.Callbacks.drop_closures_ReferencesCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_repository_references_foreach repository' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr repository + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryReferencesForeachMethodInfo +instance (signature ~ (Ggit.Callbacks.ReferencesCallback -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryReferencesForeachMethodInfo a signature where + overloadedMethod _ = repositoryReferencesForeach + +#endif + +-- method Repository::references_foreach_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "ReferencesNameCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReferencesNameCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_references_foreach_name" ggit_repository_references_foreach_name :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + FunPtr Ggit.Callbacks.C_ReferencesNameCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "ReferencesNameCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Gathers reference names and run a callback for each one. + +To the callback is passed the name of the reference and the data pointer +passed to this function. If the callback returns something other than +0, the iteration will stop and /@error@/ will be set. +-} +repositoryReferencesForeachName :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.Callbacks.ReferencesNameCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.ReferencesNameCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryReferencesForeachName repository callback = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + callback' <- Ggit.Callbacks.mk_ReferencesNameCallback (Ggit.Callbacks.wrap_ReferencesNameCallback Nothing (Ggit.Callbacks.drop_closures_ReferencesNameCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_repository_references_foreach_name repository' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr repository + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryReferencesForeachNameMethodInfo +instance (signature ~ (Ggit.Callbacks.ReferencesNameCallback -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryReferencesForeachNameMethodInfo a signature where + overloadedMethod _ = repositoryReferencesForeachName + +#endif + +-- method Repository::remove_note +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notes_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "canonical name of the reference to use, or %NULL to use the default ref.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "author signature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "committer signature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "OID of the git object to decorate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_remove_note" ggit_repository_remove_note :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- notes_ref : TBasicType TUTF8 + Ptr Ggit.Signature.Signature -> -- author : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.Signature.Signature -> -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"}) + Ptr Ggit.OId.OId -> -- id : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Removes the note for an object. +-} +repositoryRemoveNote :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (T.Text) + {- ^ /@notesRef@/: canonical name of the reference to use, or 'Nothing' to use the default ref. -} + -> b + {- ^ /@author@/: author signature. -} + -> c + {- ^ /@committer@/: committer signature. -} + -> Ggit.OId.OId + {- ^ /@id@/: OID of the git object to decorate. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryRemoveNote repository notesRef author committer id = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeNotesRef <- case notesRef of + Nothing -> return nullPtr + Just jNotesRef -> do + jNotesRef' <- textToCString jNotesRef + return jNotesRef' + author' <- unsafeManagedPtrCastPtr author + committer' <- unsafeManagedPtrCastPtr committer + id' <- unsafeManagedPtrGetPtr id + onException (do + _ <- propagateGError $ ggit_repository_remove_note repository' maybeNotesRef author' committer' id' + touchManagedPtr repository + touchManagedPtr author + touchManagedPtr committer + touchManagedPtr id + freeMem maybeNotesRef + return () + ) (do + freeMem maybeNotesRef + ) + +#if ENABLE_OVERLOADING +data RepositoryRemoveNoteMethodInfo +instance (signature ~ (Maybe (T.Text) -> b -> c -> Ggit.OId.OId -> m ()), MonadIO m, IsRepository a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c) => O.MethodInfo RepositoryRemoveNoteMethodInfo a signature where + overloadedMethod _ = repositoryRemoveNote + +#endif + +-- method Repository::reset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target #GgitObject which is a commit or a tag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reset_type", argType = TInterface (Name {namespace = "Ggit", name = "ResetType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GgitResetType to perform.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checkout_options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GgitCheckoutOptions to be used for a HARD reset.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_reset" ggit_repository_reset :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Object.Object -> -- target : TInterface (Name {namespace = "Ggit", name = "Object"}) + CUInt -> -- reset_type : TInterface (Name {namespace = "Ggit", name = "ResetType"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- checkout_options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Performs a reset of type /@resetType@/ on /@repository@/ to /@target@/, +or /@error@/ will be set. +-} +repositoryReset :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.CheckoutOptions.IsCheckoutOptions c) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@target@/: the target 'GI.Ggit.Objects.Object.Object' which is a commit or a tag. -} + -> Ggit.Enums.ResetType + {- ^ /@resetType@/: the 'GI.Ggit.Enums.ResetType' to perform. -} + -> c + {- ^ /@checkoutOptions@/: the 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' to be used for a HARD reset. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryReset repository target resetType checkoutOptions = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + target' <- unsafeManagedPtrCastPtr target + let resetType' = (fromIntegral . fromEnum) resetType + checkoutOptions' <- unsafeManagedPtrCastPtr checkoutOptions + onException (do + propagateGError $ ggit_repository_reset repository' target' resetType' checkoutOptions' + touchManagedPtr repository + touchManagedPtr target + touchManagedPtr checkoutOptions + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryResetMethodInfo +instance (signature ~ (b -> Ggit.Enums.ResetType -> c -> m ()), MonadIO m, IsRepository a, Ggit.Object.IsObject b, Ggit.CheckoutOptions.IsCheckoutOptions c) => O.MethodInfo RepositoryResetMethodInfo a signature where + overloadedMethod _ = repositoryReset + +#endif + +-- method Repository::reset_default +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Ggit", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the target #GgitObject which is a commit or a tag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pathspecs", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a list of file paths to reset.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_reset_default" ggit_repository_reset_default :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Object.Object -> -- target : TInterface (Name {namespace = "Ggit", name = "Object"}) + Ptr CString -> -- pathspecs : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Update some entries in the index from the target commit tree. The scope of +the updated entries is determined by the paths specified in /@pathspecs@/. +Passing 'Nothing' in /@target@/ will result in removing entries in the index +matching the provided pathspecs. +-} +repositoryResetDefault :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Object.IsObject b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Maybe (b) + {- ^ /@target@/: the target 'GI.Ggit.Objects.Object.Object' which is a commit or a tag. -} + -> [T.Text] + {- ^ /@pathspecs@/: a list of file paths to reset. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryResetDefault repository target pathspecs = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + maybeTarget <- case target of + Nothing -> return nullPtr + Just jTarget -> do + jTarget' <- unsafeManagedPtrCastPtr jTarget + return jTarget' + pathspecs' <- packZeroTerminatedUTF8CArray pathspecs + onException (do + propagateGError $ ggit_repository_reset_default repository' maybeTarget pathspecs' + touchManagedPtr repository + whenJust target touchManagedPtr + mapZeroTerminatedCArray freeMem pathspecs' + freeMem pathspecs' + return () + ) (do + mapZeroTerminatedCArray freeMem pathspecs' + freeMem pathspecs' + ) + +#if ENABLE_OVERLOADING +data RepositoryResetDefaultMethodInfo +instance (signature ~ (Maybe (b) -> [T.Text] -> m ()), MonadIO m, IsRepository a, Ggit.Object.IsObject b) => O.MethodInfo RepositoryResetDefaultMethodInfo a signature where + overloadedMethod _ = repositoryResetDefault + +#endif + +-- method Repository::revert +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "RevertOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevertOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_revert" ggit_repository_revert :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Commit.Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + Ptr Ggit.RevertOptions.RevertOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "RevertOptions"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Revert the given /@commit@/ on top of the current working directory. +-} +repositoryRevert :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Commit.IsCommit b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> Ggit.RevertOptions.RevertOptions + {- ^ /@options@/: a 'GI.Ggit.Structs.RevertOptions.RevertOptions'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryRevert repository commit options = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + commit' <- unsafeManagedPtrCastPtr commit + options' <- unsafeManagedPtrGetPtr options + onException (do + _ <- propagateGError $ ggit_repository_revert repository' commit' options' + touchManagedPtr repository + touchManagedPtr commit + touchManagedPtr options + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryRevertMethodInfo +instance (signature ~ (b -> Ggit.RevertOptions.RevertOptions -> m ()), MonadIO m, IsRepository a, Ggit.Commit.IsCommit b) => O.MethodInfo RepositoryRevertMethodInfo a signature where + overloadedMethod _ = repositoryRevert + +#endif + +-- method Repository::revparse +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "spec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the revision specification.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Object"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_revparse" ggit_repository_revparse :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- spec : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Object.Object) + +{- | +Find an object, as specified by a revision string. See @man gitrevisions@, +or the documentation for @git rev-parse@ for information on the syntax +accepted. +-} +repositoryRevparse :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@spec@/: the revision specification. -} + -> m (Maybe Ggit.Object.Object) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Object.Object' or 'Nothing' if the revision could not be found. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryRevparse repository spec = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + spec' <- textToCString spec + onException (do + result <- propagateGError $ ggit_repository_revparse repository' spec' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Object.Object) result' + return result'' + touchManagedPtr repository + freeMem spec' + return maybeResult + ) (do + freeMem spec' + ) + +#if ENABLE_OVERLOADING +data RepositoryRevparseMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.Object.Object)), MonadIO m, IsRepository a) => O.MethodInfo RepositoryRevparseMethodInfo a signature where + overloadedMethod _ = repositoryRevparse + +#endif + +-- method Repository::save_stash +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stasher", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "description along with the stashed state or %NULL to be autogenerated.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "StashFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitStashFlags to control the stashing process.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_save_stash" ggit_repository_save_stash :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Ggit.Signature.Signature -> -- stasher : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "StashFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Saves the local modifications to a new stash. +It returns the commit containing the stashed state. +This commit is also the target of the direct reference refs\/stash. +-} +repositorySaveStash :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Ggit.Signature.IsSignature b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@stasher@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> T.Text + {- ^ /@message@/: description along with the stashed state or 'Nothing' to be autogenerated. -} + -> [Ggit.Flags.StashFlags] + {- ^ /@flags@/: a 'GI.Ggit.Flags.StashFlags' to control the stashing process. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a new object id of the commit containing the stashed state. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositorySaveStash repository stasher message flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + stasher' <- unsafeManagedPtrCastPtr stasher + message' <- textToCString message + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ ggit_repository_save_stash repository' stasher' message' flags' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr repository + touchManagedPtr stasher + freeMem message' + return maybeResult + ) (do + freeMem message' + ) + +#if ENABLE_OVERLOADING +data RepositorySaveStashMethodInfo +instance (signature ~ (b -> T.Text -> [Ggit.Flags.StashFlags] -> m (Maybe Ggit.OId.OId)), MonadIO m, IsRepository a, Ggit.Signature.IsSignature b) => O.MethodInfo RepositorySaveStashMethodInfo a signature where + overloadedMethod _ = repositorySaveStash + +#endif + +-- method Repository::set_head +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "canonical name of the reference HEAD should point to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_set_head" ggit_repository_set_head :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- ref_name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repositorySetHead :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@refName@/: canonical name of the reference HEAD should point to. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositorySetHead repository refName = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + refName' <- textToCString refName + onException (do + _ <- propagateGError $ ggit_repository_set_head repository' refName' + touchManagedPtr repository + freeMem refName' + return () + ) (do + freeMem refName' + ) + +#if ENABLE_OVERLOADING +data RepositorySetHeadMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositorySetHeadMethodInfo a signature where + overloadedMethod _ = repositorySetHead + +#endif + +-- method Repository::set_submodule_fetch_recurse +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fetch_recurse_submodules", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleRecurse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmoduleRecurse.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_set_submodule_fetch_recurse" ggit_repository_set_submodule_fetch_recurse :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CUInt -> -- fetch_recurse_submodules : TInterface (Name {namespace = "Ggit", name = "SubmoduleRecurse"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Sets the submodule.\'name\'.fetchRecurseSubmodules value for +the submodule. This setting won\'t affect any existing instances.. +-} +repositorySetSubmoduleFetchRecurse :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> Ggit.Enums.SubmoduleRecurse + {- ^ /@fetchRecurseSubmodules@/: a 'GI.Ggit.Enums.SubmoduleRecurse'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositorySetSubmoduleFetchRecurse repository name fetchRecurseSubmodules = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + let fetchRecurseSubmodules' = (fromIntegral . fromEnum) fetchRecurseSubmodules + onException (do + propagateGError $ ggit_repository_set_submodule_fetch_recurse repository' name' fetchRecurseSubmodules' + touchManagedPtr repository + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleFetchRecurseMethodInfo +instance (signature ~ (T.Text -> Ggit.Enums.SubmoduleRecurse -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositorySetSubmoduleFetchRecurseMethodInfo a signature where + overloadedMethod _ = repositorySetSubmoduleFetchRecurse + +#endif + +-- method Repository::set_submodule_ignore +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ignore", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleIgnore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmoduleIgnore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_set_submodule_ignore" ggit_repository_set_submodule_ignore :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CInt -> -- ignore : TInterface (Name {namespace = "Ggit", name = "SubmoduleIgnore"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Sets the ignore rule for the submodule in the configuration. +This does not affect any currently-loaded instances.. +-} +repositorySetSubmoduleIgnore :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> Ggit.Enums.SubmoduleIgnore + {- ^ /@ignore@/: a 'GI.Ggit.Enums.SubmoduleIgnore'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositorySetSubmoduleIgnore repository name ignore = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + let ignore' = (fromIntegral . fromEnum) ignore + onException (do + propagateGError $ ggit_repository_set_submodule_ignore repository' name' ignore' + touchManagedPtr repository + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleIgnoreMethodInfo +instance (signature ~ (T.Text -> Ggit.Enums.SubmoduleIgnore -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositorySetSubmoduleIgnoreMethodInfo a signature where + overloadedMethod _ = repositorySetSubmoduleIgnore + +#endif + +-- method Repository::set_submodule_update +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmoduleUpdate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_set_submodule_update" ggit_repository_set_submodule_update :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CUInt -> -- update : TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdate"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Sets the update rule for the submodule in the configuration. +This setting won\'t affect any existing instances. +-} +repositorySetSubmoduleUpdate :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule. -} + -> Ggit.Enums.SubmoduleUpdate + {- ^ /@update@/: a 'GI.Ggit.Enums.SubmoduleUpdate'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositorySetSubmoduleUpdate repository name update = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + let update' = (fromIntegral . fromEnum) update + onException (do + propagateGError $ ggit_repository_set_submodule_update repository' name' update' + touchManagedPtr repository + freeMem name' + return () + ) (do + freeMem name' + ) + +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleUpdateMethodInfo +instance (signature ~ (T.Text -> Ggit.Enums.SubmoduleUpdate -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositorySetSubmoduleUpdateMethodInfo a signature where + overloadedMethod _ = repositorySetSubmoduleUpdate + +#endif + +-- method Repository::set_submodule_url +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the submodule to configure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "URL that should be used for the submodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_set_submodule_url" ggit_repository_set_submodule_url :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- url : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Sets the URL for the submodule in the configuration. + +After calling this, you may wish to call 'GI.Ggit.Structs.Submodule.submoduleSync' to +write the changes to the checked out submodule repository. +-} +repositorySetSubmoduleUrl :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> T.Text + {- ^ /@name@/: the name of the submodule to configure. -} + -> T.Text + {- ^ /@url@/: URL that should be used for the submodule. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositorySetSubmoduleUrl repository name url = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + name' <- textToCString name + url' <- textToCString url + onException (do + propagateGError $ ggit_repository_set_submodule_url repository' name' url' + touchManagedPtr repository + freeMem name' + freeMem url' + return () + ) (do + freeMem name' + freeMem url' + ) + +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleUrlMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositorySetSubmoduleUrlMethodInfo a signature where + overloadedMethod _ = repositorySetSubmoduleUrl + +#endif + +-- method Repository::set_workdir +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workdir", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the working directory.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update_gitlink", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "create/update gitlink in workdir.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_repository_set_workdir" ggit_repository_set_workdir :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr Gio.File.File -> -- workdir : TInterface (Name {namespace = "Gio", name = "File"}) + CInt -> -- update_gitlink : TBasicType TBoolean + IO () + +{- | +Sets the working directory of the repository. If /@updateGitlink@/ is set to +'True' \"core.worktree\" will be set in the config if workdir is not the parent +of the .git directory). +-} +repositorySetWorkdir :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a, Gio.File.IsFile b) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> b + {- ^ /@workdir@/: the working directory. -} + -> Bool + {- ^ /@updateGitlink@/: create\/update gitlink in workdir. -} + -> m () +repositorySetWorkdir repository workdir updateGitlink = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + workdir' <- unsafeManagedPtrCastPtr workdir + let updateGitlink' = (fromIntegral . fromEnum) updateGitlink + ggit_repository_set_workdir repository' workdir' updateGitlink' + touchManagedPtr repository + touchManagedPtr workdir + return () + +#if ENABLE_OVERLOADING +data RepositorySetWorkdirMethodInfo +instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsRepository a, Gio.File.IsFile b) => O.MethodInfo RepositorySetWorkdirMethodInfo a signature where + overloadedMethod _ = repositorySetWorkdir + +#endif + +-- method Repository::stash_foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "StashCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitStashCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_stash_foreach" ggit_repository_stash_foreach :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + FunPtr Ggit.Callbacks.C_StashCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "StashCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Loops over all the stashed states and issue a callback for each one. +If /@callback@/ returns a non-zero value, this will stop looping. +-} +repositoryStashForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.Callbacks.StashCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.StashCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryStashForeach repository callback = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + callback' <- Ggit.Callbacks.mk_StashCallback (Ggit.Callbacks.wrap_StashCallback Nothing (Ggit.Callbacks.drop_closures_StashCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_repository_stash_foreach repository' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr repository + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryStashForeachMethodInfo +instance (signature ~ (Ggit.Callbacks.StashCallback -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryStashForeachMethodInfo a signature where + overloadedMethod _ = repositoryStashForeach + +#endif + +-- method Repository::submodule_foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitStatusCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_submodule_foreach" ggit_repository_submodule_foreach :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + FunPtr Ggit.Callbacks.C_SubmoduleCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "SubmoduleCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Gathers submodules and run a callback for each one. + +To the callback is passed the submodule instance and name. If the callback +returns something other than 0, the iteration will stop and /@error@/ +will be set. + +NOTE: the submodule instance passed to the callback is only valid during +the call to ggit_repository_submodule_foreach and may not be used after the +call has finished. +-} +repositorySubmoduleForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.Callbacks.SubmoduleCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.StatusCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositorySubmoduleForeach repository callback = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + callback' <- Ggit.Callbacks.mk_SubmoduleCallback (Ggit.Callbacks.wrap_SubmoduleCallback Nothing (Ggit.Callbacks.drop_closures_SubmoduleCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_repository_submodule_foreach repository' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr repository + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data RepositorySubmoduleForeachMethodInfo +instance (signature ~ (Ggit.Callbacks.SubmoduleCallback -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositorySubmoduleForeachMethodInfo a signature where + overloadedMethod _ = repositorySubmoduleForeach + +#endif + +-- method Repository::tag_foreach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "TagCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTagCallback.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_tag_foreach" ggit_repository_tag_foreach :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + FunPtr Ggit.Callbacks.C_TagCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "TagCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Get all the tags in the repository and run the provided callback on each. If +the callback returns something other than 0, the iteration will stop and +/@error@/ will be set. +-} +repositoryTagForeach :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> Ggit.Callbacks.TagCallback + {- ^ /@callback@/: a 'GI.Ggit.Callbacks.TagCallback'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryTagForeach repository callback = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + callback' <- Ggit.Callbacks.mk_TagCallback (Ggit.Callbacks.wrap_TagCallback Nothing (Ggit.Callbacks.drop_closures_TagCallback callback)) + let userData = nullPtr + onException (do + _ <- propagateGError $ ggit_repository_tag_foreach repository' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr repository + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryTagForeachMethodInfo +instance (signature ~ (Ggit.Callbacks.TagCallback -> m ()), MonadIO m, IsRepository a) => O.MethodInfo RepositoryTagForeachMethodInfo a signature where + overloadedMethod _ = repositoryTagForeach + +#endif + +-- method Repository::clone +-- method type : MemberFunction +-- Args : [Arg {argCName = "url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "url to fetch the repository from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the location of the repository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "CloneOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitCloneOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_clone" ggit_repository_clone :: + CString -> -- url : TBasicType TUTF8 + Ptr Gio.File.File -> -- location : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr Ggit.CloneOptions.CloneOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "CloneOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Repository) + +{- | +Clones a new git repository in the given folder. +-} +repositoryClone :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Ggit.CloneOptions.IsCloneOptions b) => + T.Text + {- ^ /@url@/: url to fetch the repository from. -} + -> a + {- ^ /@location@/: the location of the repository. -} + -> Maybe (b) + {- ^ /@options@/: a 'GI.Ggit.Objects.CloneOptions.CloneOptions'. -} + -> m (Maybe Repository) + {- ^ __Returns:__ a newly created 'GI.Ggit.Objects.Repository.Repository'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryClone url location options = liftIO $ do + url' <- textToCString url + location' <- unsafeManagedPtrCastPtr location + maybeOptions <- case options of + Nothing -> return nullPtr + Just jOptions -> do + jOptions' <- unsafeManagedPtrCastPtr jOptions + return jOptions' + onException (do + result <- propagateGError $ ggit_repository_clone url' location' maybeOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Repository) result' + return result'' + touchManagedPtr location + whenJust options touchManagedPtr + freeMem url' + return maybeResult + ) (do + freeMem url' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::discover +-- method type : MemberFunction +-- Args : [Arg {argCName = "location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the base location where the lookup starts.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_discover" ggit_repository_discover :: + Ptr Gio.File.File -> -- location : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Gio.File.File) + +{- | +Looks for a git repository. + +The lookup starts from /@path@/ and walks up the parent directories +and stops when a repository is found. +-} +repositoryDiscover :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@location@/: the base location where the lookup starts. -} + -> m (Maybe Gio.File.File) + {- ^ __Returns:__ the repository location. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryDiscover location = liftIO $ do + location' <- unsafeManagedPtrCastPtr location + onException (do + result <- propagateGError $ ggit_repository_discover location' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Gio.File.File) result' + return result'' + touchManagedPtr location + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::discover_full +-- method type : MemberFunction +-- Args : [Arg {argCName = "location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the base location where the lookup starts.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "across_fs", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "indictaes whether lookup will work across filesystem devices.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ceiling_dirs", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of absolute paths\n at which lookup will stop when reached, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_discover_full" ggit_repository_discover_full :: + Ptr Gio.File.File -> -- location : TInterface (Name {namespace = "Gio", name = "File"}) + CInt -> -- across_fs : TBasicType TBoolean + Ptr CString -> -- ceiling_dirs : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr (Ptr GError) -> -- error + IO (Ptr Gio.File.File) + +{- | +Looks for a git repository. + +The lookup starts from /@path@/ and walks up the parent directories +and stops when a repository is found. +-} +repositoryDiscoverFull :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@location@/: the base location where the lookup starts. -} + -> Bool + {- ^ /@acrossFs@/: indictaes whether lookup will work across filesystem devices. -} + -> Maybe ([T.Text]) + {- ^ /@ceilingDirs@/: a list of absolute paths + at which lookup will stop when reached, or 'Nothing'. -} + -> m (Maybe Gio.File.File) + {- ^ __Returns:__ the repository location. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryDiscoverFull location acrossFs ceilingDirs = liftIO $ do + location' <- unsafeManagedPtrCastPtr location + let acrossFs' = (fromIntegral . fromEnum) acrossFs + maybeCeilingDirs <- case ceilingDirs of + Nothing -> return nullPtr + Just jCeilingDirs -> do + jCeilingDirs' <- packZeroTerminatedUTF8CArray jCeilingDirs + return jCeilingDirs' + onException (do + result <- propagateGError $ ggit_repository_discover_full location' acrossFs' maybeCeilingDirs + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Gio.File.File) result' + return result'' + touchManagedPtr location + mapZeroTerminatedCArray freeMem maybeCeilingDirs + freeMem maybeCeilingDirs + return maybeResult + ) (do + mapZeroTerminatedCArray freeMem maybeCeilingDirs + freeMem maybeCeilingDirs + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::init_repository +-- method type : MemberFunction +-- Args : [Arg {argCName = "location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the location of the repository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_bare", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE, a git repository without a working directory is created\n at the pointed path. If %FALSE, provided path will be considered as the working\n directory into which the .git directory will be created.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_init_repository" ggit_repository_init_repository :: + Ptr Gio.File.File -> -- location : TInterface (Name {namespace = "Gio", name = "File"}) + CInt -> -- is_bare : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO (Ptr Repository) + +{- | +Creates a new git repository in the given folder. +-} +repositoryInitRepository :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@location@/: the location of the repository. -} + -> Bool + {- ^ /@isBare@/: if 'True', a git repository without a working directory is created + at the pointed path. If 'False', provided path will be considered as the working + directory into which the .git directory will be created. -} + -> m (Maybe Repository) + {- ^ __Returns:__ a newly created 'GI.Ggit.Objects.Repository.Repository'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryInitRepository location isBare = liftIO $ do + location' <- unsafeManagedPtrCastPtr location + let isBare' = (fromIntegral . fromEnum) isBare + onException (do + result <- propagateGError $ ggit_repository_init_repository location' isBare' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Repository) result' + return result'' + touchManagedPtr location + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::open +-- method type : MemberFunction +-- Args : [Arg {argCName = "location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the location of the repository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_repository_open" ggit_repository_open :: + Ptr Gio.File.File -> -- location : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Repository) + +{- | +Open a git repository. + +The /@path@/ must point to an existing git repository folder, e.g. + + \/path\/to\/my_repo\/.git\/ (normal repository) + objects\/ + index + HEAD + + \/path\/to\/bare_repo\/ (bare repository) + objects\/ + index + HEAD + +The method will automatically detect if /@path@/ is a normal +or bare repository or fail if it is neither. +-} +repositoryOpen :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + a + {- ^ /@location@/: the location of the repository. -} + -> m (Maybe Repository) + {- ^ __Returns:__ a newly created 'GI.Ggit.Objects.Repository.Repository'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryOpen location = liftIO $ do + location' <- unsafeManagedPtrCastPtr location + onException (do + result <- propagateGError $ ggit_repository_open location' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Repository) result' + return result'' + touchManagedPtr location + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/Ggit/Objects/Repository.hs-boot b/GI/Ggit/Objects/Repository.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Repository.hs-boot @@ -0,0 +1,299 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Repository 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 + +newtype Repository = Repository (ManagedPtr Repository) +instance GObject Repository where +class (GObject o, O.IsDescendantOf Repository o) => IsRepository o +instance (GObject o, O.IsDescendantOf Repository o) => IsRepository o +instance O.HasParentTypes Repository +#if ENABLE_OVERLOADING +data RepositoryCloneOptionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryHeadPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryInitPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryIsBarePropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLocationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryUrlPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryWorkdirPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryAddRemoteFetchMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryAddRemotePushMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryBlameFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCheckoutHeadMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCheckoutIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCheckoutTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCherryPickMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCherryPickCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateBlobMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateBlobFromBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateBlobFromFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateBlobFromPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateBranchMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateCommitFromIdsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateIndexEntryForFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateIndexEntryForPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateNoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateReferenceMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateRemoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateSymbolicReferenceMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateTagMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateTagAnnotationMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateTagFromBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateTagLightweightMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateTreeBuilderMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryCreateTreeBuilderFromTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryDeleteTagMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryDropStashMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryEnumerateBranchesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryFileStatusMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryFileStatusForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetAheadBehindMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetAttributeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetConfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetDefaultNotesRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetDescendantOfMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetHeadMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetLocationMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetSubmoduleStatusMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetWorkdirMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryIsBareMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryIsEmptyMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryIsHeadDetachedMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryIsHeadUnbornMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryListRemotesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryListTagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryListTagsMatchMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupBlobMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupBranchMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupReferenceMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupReferenceDwimMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupRemoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupSubmoduleMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupTagMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLookupTreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryMergeCommitsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryMergeTreesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryNoteForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryPathIsIgnoredMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryReadNoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryRebaseInitMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryRebaseOpenMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryReferencesForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryReferencesForeachNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryRemoveNoteMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryResetMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryResetDefaultMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryRevertMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryRevparseMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySaveStashMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySetHeadMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleFetchRecurseMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleIgnoreMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleUpdateMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySetSubmoduleUrlMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySetWorkdirMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryStashForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositorySubmoduleForeachMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryTagForeachMethodInfo +#endif diff --git a/GI/Ggit/Objects/RevisionWalker.hs b/GI/Ggit/Objects/RevisionWalker.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/RevisionWalker.hs @@ -0,0 +1,959 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a revision walker. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.RevisionWalker + ( + +-- * Exported types + RevisionWalker(..) , + IsRevisionWalker , + toRevisionWalker , + noRevisionWalker , + + + -- * Methods +-- ** getRepository #method:getRepository# + +#if ENABLE_OVERLOADING + RevisionWalkerGetRepositoryMethodInfo , +#endif + revisionWalkerGetRepository , + + +-- ** hide #method:hide# + +#if ENABLE_OVERLOADING + RevisionWalkerHideMethodInfo , +#endif + revisionWalkerHide , + + +-- ** hideGlob #method:hideGlob# + +#if ENABLE_OVERLOADING + RevisionWalkerHideGlobMethodInfo , +#endif + revisionWalkerHideGlob , + + +-- ** hideHead #method:hideHead# + +#if ENABLE_OVERLOADING + RevisionWalkerHideHeadMethodInfo , +#endif + revisionWalkerHideHead , + + +-- ** hideRef #method:hideRef# + +#if ENABLE_OVERLOADING + RevisionWalkerHideRefMethodInfo , +#endif + revisionWalkerHideRef , + + +-- ** new #method:new# + + revisionWalkerNew , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + RevisionWalkerNextMethodInfo , +#endif + revisionWalkerNext , + + +-- ** push #method:push# + +#if ENABLE_OVERLOADING + RevisionWalkerPushMethodInfo , +#endif + revisionWalkerPush , + + +-- ** pushGlob #method:pushGlob# + +#if ENABLE_OVERLOADING + RevisionWalkerPushGlobMethodInfo , +#endif + revisionWalkerPushGlob , + + +-- ** pushHead #method:pushHead# + +#if ENABLE_OVERLOADING + RevisionWalkerPushHeadMethodInfo , +#endif + revisionWalkerPushHead , + + +-- ** pushRange #method:pushRange# + +#if ENABLE_OVERLOADING + RevisionWalkerPushRangeMethodInfo , +#endif + revisionWalkerPushRange , + + +-- ** pushRef #method:pushRef# + +#if ENABLE_OVERLOADING + RevisionWalkerPushRefMethodInfo , +#endif + revisionWalkerPushRef , + + +-- ** reset #method:reset# + +#if ENABLE_OVERLOADING + RevisionWalkerResetMethodInfo , +#endif + revisionWalkerReset , + + +-- ** setSortMode #method:setSortMode# + +#if ENABLE_OVERLOADING + RevisionWalkerSetSortModeMethodInfo , +#endif + revisionWalkerSetSortMode , + + + + + -- * Properties +-- ** repository #attr:repository# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + RevisionWalkerRepositoryPropertyInfo , +#endif + clearRevisionWalkerRepository , + constructRevisionWalkerRepository , + getRevisionWalkerRepository , +#if ENABLE_OVERLOADING + revisionWalkerRepository , +#endif + setRevisionWalkerRepository , + + + + + ) 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.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import qualified GI.Gio.Interfaces.Initable as Gio.Initable + +-- | Memory-managed wrapper type. +newtype RevisionWalker = RevisionWalker (ManagedPtr RevisionWalker) +foreign import ccall "ggit_revision_walker_get_type" + c_ggit_revision_walker_get_type :: IO GType + +instance GObject RevisionWalker where + gobjectType = c_ggit_revision_walker_get_type + + +-- | Type class for types which can be safely cast to `RevisionWalker`, for instance with `toRevisionWalker`. +class (GObject o, O.IsDescendantOf RevisionWalker o) => IsRevisionWalker o +instance (GObject o, O.IsDescendantOf RevisionWalker o) => IsRevisionWalker o + +instance O.HasParentTypes RevisionWalker +type instance O.ParentTypes RevisionWalker = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object, Gio.Initable.Initable] + +-- | Cast to `RevisionWalker`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRevisionWalker :: (MonadIO m, IsRevisionWalker o) => o -> m RevisionWalker +toRevisionWalker = liftIO . unsafeCastTo RevisionWalker + +-- | A convenience alias for `Nothing` :: `Maybe` `RevisionWalker`. +noRevisionWalker :: Maybe RevisionWalker +noRevisionWalker = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRevisionWalkerMethod (t :: Symbol) (o :: *) :: * where + ResolveRevisionWalkerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRevisionWalkerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRevisionWalkerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRevisionWalkerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRevisionWalkerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRevisionWalkerMethod "hide" o = RevisionWalkerHideMethodInfo + ResolveRevisionWalkerMethod "hideGlob" o = RevisionWalkerHideGlobMethodInfo + ResolveRevisionWalkerMethod "hideHead" o = RevisionWalkerHideHeadMethodInfo + ResolveRevisionWalkerMethod "hideRef" o = RevisionWalkerHideRefMethodInfo + ResolveRevisionWalkerMethod "init" o = Gio.Initable.InitableInitMethodInfo + ResolveRevisionWalkerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRevisionWalkerMethod "next" o = RevisionWalkerNextMethodInfo + ResolveRevisionWalkerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRevisionWalkerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRevisionWalkerMethod "push" o = RevisionWalkerPushMethodInfo + ResolveRevisionWalkerMethod "pushGlob" o = RevisionWalkerPushGlobMethodInfo + ResolveRevisionWalkerMethod "pushHead" o = RevisionWalkerPushHeadMethodInfo + ResolveRevisionWalkerMethod "pushRange" o = RevisionWalkerPushRangeMethodInfo + ResolveRevisionWalkerMethod "pushRef" o = RevisionWalkerPushRefMethodInfo + ResolveRevisionWalkerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRevisionWalkerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRevisionWalkerMethod "reset" o = RevisionWalkerResetMethodInfo + ResolveRevisionWalkerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRevisionWalkerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRevisionWalkerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRevisionWalkerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRevisionWalkerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRevisionWalkerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRevisionWalkerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRevisionWalkerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRevisionWalkerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRevisionWalkerMethod "getRepository" o = RevisionWalkerGetRepositoryMethodInfo + ResolveRevisionWalkerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRevisionWalkerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRevisionWalkerMethod "setSortMode" o = RevisionWalkerSetSortModeMethodInfo + ResolveRevisionWalkerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRevisionWalkerMethod t RevisionWalker, O.MethodInfo info RevisionWalker p) => OL.IsLabel t (RevisionWalker -> 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 + +-- VVV Prop "repository" + -- Type: TInterface (Name {namespace = "Ggit", name = "Repository"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@repository@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' revisionWalker #repository +@ +-} +getRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o) => o -> m (Maybe Ggit.Repository.Repository) +getRevisionWalkerRepository obj = liftIO $ B.Properties.getObjectPropertyObject obj "repository" Ggit.Repository.Repository + +{- | +Set the value of the “@repository@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' revisionWalker [ #repository 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o, Ggit.Repository.IsRepository a) => o -> a -> m () +setRevisionWalkerRepository obj val = liftIO $ B.Properties.setObjectPropertyObject obj "repository" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@repository@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRevisionWalkerRepository :: (IsRevisionWalker o, Ggit.Repository.IsRepository a) => a -> IO (GValueConstruct o) +constructRevisionWalkerRepository val = B.Properties.constructObjectPropertyObject "repository" (Just val) + +{- | +Set the value of the “@repository@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #repository +@ +-} +clearRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o) => o -> m () +clearRevisionWalkerRepository obj = liftIO $ B.Properties.setObjectPropertyObject obj "repository" (Nothing :: Maybe Ggit.Repository.Repository) + +#if ENABLE_OVERLOADING +data RevisionWalkerRepositoryPropertyInfo +instance AttrInfo RevisionWalkerRepositoryPropertyInfo where + type AttrAllowedOps RevisionWalkerRepositoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RevisionWalkerRepositoryPropertyInfo = Ggit.Repository.IsRepository + type AttrBaseTypeConstraint RevisionWalkerRepositoryPropertyInfo = IsRevisionWalker + type AttrGetType RevisionWalkerRepositoryPropertyInfo = (Maybe Ggit.Repository.Repository) + type AttrLabel RevisionWalkerRepositoryPropertyInfo = "repository" + type AttrOrigin RevisionWalkerRepositoryPropertyInfo = RevisionWalker + attrGet _ = getRevisionWalkerRepository + attrSet _ = setRevisionWalkerRepository + attrConstruct _ = constructRevisionWalkerRepository + attrClear _ = clearRevisionWalkerRepository +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RevisionWalker +type instance O.AttributeList RevisionWalker = RevisionWalkerAttributeList +type RevisionWalkerAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo), '("repository", RevisionWalkerRepositoryPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +revisionWalkerRepository :: AttrLabelProxy "repository" +revisionWalkerRepository = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList RevisionWalker = RevisionWalkerSignalList +type RevisionWalkerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method RevisionWalker::new +-- method type : Constructor +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "Ggit", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RevisionWalker"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_new" ggit_revision_walker_new :: + Ptr Ggit.Repository.Repository -> -- repository : TInterface (Name {namespace = "Ggit", name = "Repository"}) + Ptr (Ptr GError) -> -- error + IO (Ptr RevisionWalker) + +{- | +Creates a new revision walker to iterate through /@repository@/. + +This revision walker uses a custom memory pool and an internal +commit cache, so it is relatively expensive to allocate. + +For maximum performance, this revision walker should be +reused for different walks. + +This revision walker is *not* thread safe: it may only be +used to walk a repository on a single thread; however, +it is possible to have several revision walkers in +several different threads walking the same repository. +-} +revisionWalkerNew :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a) => + a + {- ^ /@repository@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe RevisionWalker) + {- ^ __Returns:__ a new 'GI.Ggit.Objects.RevisionWalker.RevisionWalker' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerNew repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + onException (do + result <- propagateGError $ ggit_revision_walker_new repository' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject RevisionWalker) result' + return result'' + touchManagedPtr repository + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method RevisionWalker::get_repository +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRepository.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_revision_walker_get_repository" ggit_revision_walker_get_repository :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + IO (Ptr Ggit.Repository.Repository) + +{- | +Gets the repository on which this walker is operating. +-} +revisionWalkerGetRepository :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.Repository.Repository'. -} + -> m (Maybe Ggit.Repository.Repository) + {- ^ __Returns:__ the repository on which this walker is operating or 'Nothing'. -} +revisionWalkerGetRepository walker = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + result <- ggit_revision_walker_get_repository walker' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.Repository.Repository) result' + return result'' + touchManagedPtr walker + return maybeResult + +#if ENABLE_OVERLOADING +data RevisionWalkerGetRepositoryMethodInfo +instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerGetRepositoryMethodInfo a signature where + overloadedMethod _ = revisionWalkerGetRepository + +#endif + +-- method RevisionWalker::hide +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_hide" ggit_revision_walker_hide :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Marks a commit (and its ancestors) uninteresting for the output. + +The given OID must belong to a commit on the walked +repository. + +The resolved commit and all its parents will be hidden from the +output on the revision walk. +-} +revisionWalkerHide :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerHide walker oid = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + oid' <- unsafeManagedPtrGetPtr oid + onException (do + propagateGError $ ggit_revision_walker_hide walker' oid' + touchManagedPtr walker + touchManagedPtr oid + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerHideMethodInfo +instance (signature ~ (Ggit.OId.OId -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideMethodInfo a signature where + overloadedMethod _ = revisionWalkerHide + +#endif + +-- method RevisionWalker::hide_glob +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the glob to hide.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_hide_glob" ggit_revision_walker_hide_glob :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + CString -> -- item : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Hide all OIDs pointed to by references that match the given glob pattern +to the revsision walker. A leading \'refs\/\' is implied if not present, as well +as a trailing \'\/ \\ *\' if the glob lacks \'?\', \'\\ *\' or \'[\'. +-} +revisionWalkerHideGlob :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> T.Text + {- ^ /@item@/: the glob to hide. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerHideGlob walker item = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + item' <- textToCString item + onException (do + propagateGError $ ggit_revision_walker_hide_glob walker' item' + touchManagedPtr walker + freeMem item' + return () + ) (do + freeMem item' + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerHideGlobMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideGlobMethodInfo a signature where + overloadedMethod _ = revisionWalkerHideGlob + +#endif + +-- method RevisionWalker::hide_head +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_hide_head" ggit_revision_walker_hide_head :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Hide the OID of the current HEAD to the revision walker. +-} +revisionWalkerHideHead :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerHideHead walker = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + onException (do + propagateGError $ ggit_revision_walker_hide_head walker' + touchManagedPtr walker + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerHideHeadMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideHeadMethodInfo a signature where + overloadedMethod _ = revisionWalkerHideHead + +#endif + +-- method RevisionWalker::hide_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference to hide.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_hide_ref" ggit_revision_walker_hide_ref :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + CString -> -- item : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Hide the OID pointed to by the named reference to the revision walker. +-} +revisionWalkerHideRef :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> T.Text + {- ^ /@item@/: the reference to hide. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerHideRef walker item = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + item' <- textToCString item + onException (do + propagateGError $ ggit_revision_walker_hide_ref walker' item' + touchManagedPtr walker + freeMem item' + return () + ) (do + freeMem item' + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerHideRefMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerHideRefMethodInfo a signature where + overloadedMethod _ = revisionWalkerHideRef + +#endif + +-- method RevisionWalker::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_next" ggit_revision_walker_next :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Gets the next commit from the revision walk. + +The initial call to this method is *not* blocking when +iterating through a repository with a time-sorting mode. + +Iterating with Topological or inverted modes makes the initial +call blocking to preprocess the commit list, but this block should be +mostly unnoticeable on most repositories (topological preprocessing +times at 0.3s on the git.git repo). + +The revision walker is reset when the walk is over. +-} +revisionWalkerNext :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the next commit from the revision walk or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerNext walker = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + onException (do + result <- propagateGError $ ggit_revision_walker_next walker' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr walker + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerNextMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerNextMethodInfo a signature where + overloadedMethod _ = revisionWalkerNext + +#endif + +-- method RevisionWalker::push +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_push" ggit_revision_walker_push :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Marks a commit to start traversal from. + +The given OID must belong to a commit on the walked +repository. + +The given commit will be used as one of the roots +when starting the revision walk. At least one commit +must be pushed the repository before a walk can +be started. +-} +revisionWalkerPush :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerPush walker oid = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + oid' <- unsafeManagedPtrGetPtr oid + onException (do + propagateGError $ ggit_revision_walker_push walker' oid' + touchManagedPtr walker + touchManagedPtr oid + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerPushMethodInfo +instance (signature ~ (Ggit.OId.OId -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushMethodInfo a signature where + overloadedMethod _ = revisionWalkerPush + +#endif + +-- method RevisionWalker::push_glob +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the glob to push.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_push_glob" ggit_revision_walker_push_glob :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + CString -> -- item : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Push all OIDs pointed to by references that match the given glob pattern +to the revsision walker. A leading \'refs\/\' is implied if not present, as well +as a trailing \'\/ \\ *\' if the glob lacks \'?\', \'\\ *\' or \'[\'. +-} +revisionWalkerPushGlob :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> T.Text + {- ^ /@item@/: the glob to push. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerPushGlob walker item = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + item' <- textToCString item + onException (do + propagateGError $ ggit_revision_walker_push_glob walker' item' + touchManagedPtr walker + freeMem item' + return () + ) (do + freeMem item' + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerPushGlobMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushGlobMethodInfo a signature where + overloadedMethod _ = revisionWalkerPushGlob + +#endif + +-- method RevisionWalker::push_head +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_push_head" ggit_revision_walker_push_head :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Push the OID of the current HEAD to the revision walker. +-} +revisionWalkerPushHead :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerPushHead walker = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + onException (do + propagateGError $ ggit_revision_walker_push_head walker' + touchManagedPtr walker + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerPushHeadMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushHeadMethodInfo a signature where + overloadedMethod _ = revisionWalkerPushHead + +#endif + +-- method RevisionWalker::push_range +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "range", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the range to push.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_push_range" ggit_revision_walker_push_range :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + CString -> -- range : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Push and hide the respective endpoints of the given range. The range +should be of the form: <commit>..<commit>, where each <commit> is in the +form accepted by revparse. The left-hand commit will be hidden and the +right-hand commit pushed. +-} +revisionWalkerPushRange :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> T.Text + {- ^ /@range@/: the range to push. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerPushRange walker range = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + range' <- textToCString range + onException (do + propagateGError $ ggit_revision_walker_push_range walker' range' + touchManagedPtr walker + freeMem range' + return () + ) (do + freeMem range' + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerPushRangeMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushRangeMethodInfo a signature where + overloadedMethod _ = revisionWalkerPushRange + +#endif + +-- method RevisionWalker::push_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the reference to push.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_revision_walker_push_ref" ggit_revision_walker_push_ref :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + CString -> -- item : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Push the OID pointed to by the named reference to the revision walker. +-} +revisionWalkerPushRef :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> T.Text + {- ^ /@item@/: the reference to push. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +revisionWalkerPushRef walker item = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + item' <- textToCString item + onException (do + propagateGError $ ggit_revision_walker_push_ref walker' item' + touchManagedPtr walker + freeMem item' + return () + ) (do + freeMem item' + ) + +#if ENABLE_OVERLOADING +data RevisionWalkerPushRefMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerPushRefMethodInfo a signature where + overloadedMethod _ = revisionWalkerPushRef + +#endif + +-- method RevisionWalker::reset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_revision_walker_reset" ggit_revision_walker_reset :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + IO () + +{- | +Resets the revision walker for reuse. + +This will clear all the pushed and hidden commits, and +leave the walker in a blank state (just like at +creation) ready to receive new commit pushes and +start a new walk. + +The revision walk is automatically reset when a walk +is over. +-} +revisionWalkerReset :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> m () +revisionWalkerReset walker = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + ggit_revision_walker_reset walker' + touchManagedPtr walker + return () + +#if ENABLE_OVERLOADING +data RevisionWalkerResetMethodInfo +instance (signature ~ (m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerResetMethodInfo a signature where + overloadedMethod _ = revisionWalkerReset + +#endif + +-- method RevisionWalker::set_sort_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "walker", argType = TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevisionWalker.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sort_mode", argType = TInterface (Name {namespace = "Ggit", name = "SortMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSortMode value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_revision_walker_set_sort_mode" ggit_revision_walker_set_sort_mode :: + Ptr RevisionWalker -> -- walker : TInterface (Name {namespace = "Ggit", name = "RevisionWalker"}) + CUInt -> -- sort_mode : TInterface (Name {namespace = "Ggit", name = "SortMode"}) + IO () + +{- | +Change the sorting mode when iterating through the +repository\'s contents. + +Changing the sorting mode resets the walker. +-} +revisionWalkerSetSortMode :: + (B.CallStack.HasCallStack, MonadIO m, IsRevisionWalker a) => + a + {- ^ /@walker@/: a 'GI.Ggit.Objects.RevisionWalker.RevisionWalker'. -} + -> [Ggit.Flags.SortMode] + {- ^ /@sortMode@/: a 'GI.Ggit.Flags.SortMode' value. -} + -> m () +revisionWalkerSetSortMode walker sortMode = liftIO $ do + walker' <- unsafeManagedPtrCastPtr walker + let sortMode' = gflagsToWord sortMode + ggit_revision_walker_set_sort_mode walker' sortMode' + touchManagedPtr walker + return () + +#if ENABLE_OVERLOADING +data RevisionWalkerSetSortModeMethodInfo +instance (signature ~ ([Ggit.Flags.SortMode] -> m ()), MonadIO m, IsRevisionWalker a) => O.MethodInfo RevisionWalkerSetSortModeMethodInfo a signature where + overloadedMethod _ = revisionWalkerSetSortMode + +#endif + + diff --git a/GI/Ggit/Objects/RevisionWalker.hs-boot b/GI/Ggit/Objects/RevisionWalker.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/RevisionWalker.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.RevisionWalker 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 + +newtype RevisionWalker = RevisionWalker (ManagedPtr RevisionWalker) +instance GObject RevisionWalker where +class (GObject o, O.IsDescendantOf RevisionWalker o) => IsRevisionWalker o +instance (GObject o, O.IsDescendantOf RevisionWalker o) => IsRevisionWalker o +instance O.HasParentTypes RevisionWalker +#if ENABLE_OVERLOADING +data RevisionWalkerRepositoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerGetRepositoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerHideMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerHideGlobMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerHideHeadMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerHideRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerNextMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerPushMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerPushGlobMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerPushHeadMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerPushRangeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerPushRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerResetMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevisionWalkerSetSortModeMethodInfo +#endif diff --git a/GI/Ggit/Objects/Signature.hs b/GI/Ggit/Objects/Signature.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Signature.hs @@ -0,0 +1,519 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents an action signature. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Signature + ( + +-- * Exported types + Signature(..) , + IsSignature , + toSignature , + noSignature , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + SignatureCopyMethodInfo , +#endif + signatureCopy , + + +-- ** getEmail #method:getEmail# + +#if ENABLE_OVERLOADING + SignatureGetEmailMethodInfo , +#endif + signatureGetEmail , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + SignatureGetNameMethodInfo , +#endif + signatureGetName , + + +-- ** getTime #method:getTime# + +#if ENABLE_OVERLOADING + SignatureGetTimeMethodInfo , +#endif + signatureGetTime , + + +-- ** getTimeZone #method:getTimeZone# + +#if ENABLE_OVERLOADING + SignatureGetTimeZoneMethodInfo , +#endif + signatureGetTimeZone , + + +-- ** new #method:new# + + signatureNew , + + +-- ** newNow #method:newNow# + + signatureNewNow , + + + + + -- * Properties +-- ** encoding #attr:encoding# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SignatureEncodingPropertyInfo , +#endif + constructSignatureEncoding , + getSignatureEncoding , +#if ENABLE_OVERLOADING + signatureEncoding , +#endif + + + + + ) 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.GLib.Structs.DateTime as GLib.DateTime +import qualified GI.GLib.Structs.TimeZone as GLib.TimeZone +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase + +-- | Memory-managed wrapper type. +newtype Signature = Signature (ManagedPtr Signature) +foreign import ccall "ggit_signature_get_type" + c_ggit_signature_get_type :: IO GType + +instance GObject Signature where + gobjectType = c_ggit_signature_get_type + + +-- | Type class for types which can be safely cast to `Signature`, for instance with `toSignature`. +class (GObject o, O.IsDescendantOf Signature o) => IsSignature o +instance (GObject o, O.IsDescendantOf Signature o) => IsSignature o + +instance O.HasParentTypes Signature +type instance O.ParentTypes Signature = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Signature`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSignature :: (MonadIO m, IsSignature o) => o -> m Signature +toSignature = liftIO . unsafeCastTo Signature + +-- | A convenience alias for `Nothing` :: `Maybe` `Signature`. +noSignature :: Maybe Signature +noSignature = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSignatureMethod (t :: Symbol) (o :: *) :: * where + ResolveSignatureMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSignatureMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSignatureMethod "copy" o = SignatureCopyMethodInfo + ResolveSignatureMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSignatureMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSignatureMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSignatureMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSignatureMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSignatureMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSignatureMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSignatureMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSignatureMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSignatureMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSignatureMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSignatureMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSignatureMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSignatureMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSignatureMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSignatureMethod "getEmail" o = SignatureGetEmailMethodInfo + ResolveSignatureMethod "getName" o = SignatureGetNameMethodInfo + ResolveSignatureMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSignatureMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSignatureMethod "getTime" o = SignatureGetTimeMethodInfo + ResolveSignatureMethod "getTimeZone" o = SignatureGetTimeZoneMethodInfo + ResolveSignatureMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSignatureMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSignatureMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSignatureMethod t Signature, O.MethodInfo info Signature p) => OL.IsLabel t (Signature -> 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 + +-- VVV Prop "encoding" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@encoding@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' signature #encoding +@ +-} +getSignatureEncoding :: (MonadIO m, IsSignature o) => o -> m (Maybe T.Text) +getSignatureEncoding obj = liftIO $ B.Properties.getObjectPropertyString obj "encoding" + +{- | +Construct a `GValueConstruct` with valid value for the “@encoding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSignatureEncoding :: (IsSignature o) => T.Text -> IO (GValueConstruct o) +constructSignatureEncoding val = B.Properties.constructObjectPropertyString "encoding" (Just val) + +#if ENABLE_OVERLOADING +data SignatureEncodingPropertyInfo +instance AttrInfo SignatureEncodingPropertyInfo where + type AttrAllowedOps SignatureEncodingPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SignatureEncodingPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SignatureEncodingPropertyInfo = IsSignature + type AttrGetType SignatureEncodingPropertyInfo = (Maybe T.Text) + type AttrLabel SignatureEncodingPropertyInfo = "encoding" + type AttrOrigin SignatureEncodingPropertyInfo = Signature + attrGet _ = getSignatureEncoding + attrSet _ = undefined + attrConstruct _ = constructSignatureEncoding + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Signature +type instance O.AttributeList Signature = SignatureAttributeList +type SignatureAttributeList = ('[ '("encoding", SignatureEncodingPropertyInfo), '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +signatureEncoding :: AttrLabelProxy "encoding" +signatureEncoding = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Signature = SignatureSignalList +type SignatureSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Signature::new +-- method type : Constructor +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the person.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "email", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the email of the person.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signature_time", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the time when the action happened.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_signature_new" ggit_signature_new :: + CString -> -- name : TBasicType TUTF8 + CString -> -- email : TBasicType TUTF8 + Ptr GLib.DateTime.DateTime -> -- signature_time : TInterface (Name {namespace = "GLib", name = "DateTime"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Signature) + +{- | +Creates a new 'GI.Ggit.Objects.Signature.Signature'. Name and e-mail are assumed to be in UTF-8. +-} +signatureNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@name@/: the name of the person. -} + -> T.Text + {- ^ /@email@/: the email of the person. -} + -> GLib.DateTime.DateTime + {- ^ /@signatureTime@/: the time when the action happened. -} + -> m (Maybe Signature) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Signature.Signature' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +signatureNew name email signatureTime = liftIO $ do + name' <- textToCString name + email' <- textToCString email + signatureTime' <- unsafeManagedPtrGetPtr signatureTime + onException (do + result <- propagateGError $ ggit_signature_new name' email' signatureTime' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Signature) result' + return result'' + touchManagedPtr signatureTime + freeMem name' + freeMem email' + return maybeResult + ) (do + freeMem name' + freeMem email' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Signature::new_now +-- method type : Constructor +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the person.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "email", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the email of the person.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_signature_new_now" ggit_signature_new_now :: + CString -> -- name : TBasicType TUTF8 + CString -> -- email : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Signature) + +{- | +Creates a new 'GI.Ggit.Objects.Signature.Signature' with a timestamp of \'now\'. Name and e-mail are +assumed to be in UTF-8. +-} +signatureNewNow :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@name@/: the name of the person. -} + -> T.Text + {- ^ /@email@/: the email of the person. -} + -> m (Maybe Signature) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Objects.Signature.Signature' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +signatureNewNow name email = liftIO $ do + name' <- textToCString name + email' <- textToCString email + onException (do + result <- propagateGError $ ggit_signature_new_now name' email' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Signature) result' + return result'' + freeMem name' + freeMem email' + return maybeResult + ) (do + freeMem name' + freeMem email' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Signature::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "signature", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_signature_copy" ggit_signature_copy :: + Ptr Signature -> -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"}) + IO (Ptr Signature) + +{- | +Create a copy of the signature. +-} +signatureCopy :: + (B.CallStack.HasCallStack, MonadIO m, IsSignature a) => + a + {- ^ /@signature@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> m (Maybe Signature) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Signature.Signature' or 'Nothing'. -} +signatureCopy signature = liftIO $ do + signature' <- unsafeManagedPtrCastPtr signature + result <- ggit_signature_copy signature' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Signature) result' + return result'' + touchManagedPtr signature + return maybeResult + +#if ENABLE_OVERLOADING +data SignatureCopyMethodInfo +instance (signature ~ (m (Maybe Signature)), MonadIO m, IsSignature a) => O.MethodInfo SignatureCopyMethodInfo a signature where + overloadedMethod _ = signatureCopy + +#endif + +-- method Signature::get_email +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "signature", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_signature_get_email" ggit_signature_get_email :: + Ptr Signature -> -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"}) + IO CString + +{- | +Gets the email of the person. +-} +signatureGetEmail :: + (B.CallStack.HasCallStack, MonadIO m, IsSignature a) => + a + {- ^ /@signature@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the email of the person or 'Nothing'. -} +signatureGetEmail signature = liftIO $ do + signature' <- unsafeManagedPtrCastPtr signature + result <- ggit_signature_get_email signature' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr signature + return maybeResult + +#if ENABLE_OVERLOADING +data SignatureGetEmailMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsSignature a) => O.MethodInfo SignatureGetEmailMethodInfo a signature where + overloadedMethod _ = signatureGetEmail + +#endif + +-- method Signature::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "signature", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_signature_get_name" ggit_signature_get_name :: + Ptr Signature -> -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"}) + IO CString + +{- | +Gets the name of the person. +-} +signatureGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsSignature a) => + a + {- ^ /@signature@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of the person or 'Nothing'. -} +signatureGetName signature = liftIO $ do + signature' <- unsafeManagedPtrCastPtr signature + result <- ggit_signature_get_name signature' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr signature + return maybeResult + +#if ENABLE_OVERLOADING +data SignatureGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsSignature a) => O.MethodInfo SignatureGetNameMethodInfo a signature where + overloadedMethod _ = signatureGetName + +#endif + +-- method Signature::get_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "signature", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "DateTime"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_signature_get_time" ggit_signature_get_time :: + Ptr Signature -> -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"}) + IO (Ptr GLib.DateTime.DateTime) + +{- | +Gets the time when the action happened. Note that the time is returned in +the timezone of the commit (see @/ggit_signature_get_time_zone/@). +-} +signatureGetTime :: + (B.CallStack.HasCallStack, MonadIO m, IsSignature a) => + a + {- ^ /@signature@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> m (Maybe GLib.DateTime.DateTime) + {- ^ __Returns:__ the time when the action happened or 'Nothing'. -} +signatureGetTime signature = liftIO $ do + signature' <- unsafeManagedPtrCastPtr signature + result <- ggit_signature_get_time signature' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed GLib.DateTime.DateTime) result' + return result'' + touchManagedPtr signature + return maybeResult + +#if ENABLE_OVERLOADING +data SignatureGetTimeMethodInfo +instance (signature ~ (m (Maybe GLib.DateTime.DateTime)), MonadIO m, IsSignature a) => O.MethodInfo SignatureGetTimeMethodInfo a signature where + overloadedMethod _ = signatureGetTime + +#endif + +-- method Signature::get_time_zone +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "signature", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "TimeZone"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_signature_get_time_zone" ggit_signature_get_time_zone :: + Ptr Signature -> -- signature : TInterface (Name {namespace = "Ggit", name = "Signature"}) + IO (Ptr GLib.TimeZone.TimeZone) + +{- | +Gets the timezone in which the action happened. +-} +signatureGetTimeZone :: + (B.CallStack.HasCallStack, MonadIO m, IsSignature a) => + a + {- ^ /@signature@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> m (Maybe GLib.TimeZone.TimeZone) + {- ^ __Returns:__ the timezone in which the action happened or 'Nothing'. -} +signatureGetTimeZone signature = liftIO $ do + signature' <- unsafeManagedPtrCastPtr signature + result <- ggit_signature_get_time_zone signature' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed GLib.TimeZone.TimeZone) result' + return result'' + touchManagedPtr signature + return maybeResult + +#if ENABLE_OVERLOADING +data SignatureGetTimeZoneMethodInfo +instance (signature ~ (m (Maybe GLib.TimeZone.TimeZone)), MonadIO m, IsSignature a) => O.MethodInfo SignatureGetTimeZoneMethodInfo a signature where + overloadedMethod _ = signatureGetTimeZone + +#endif + + diff --git a/GI/Ggit/Objects/Signature.hs-boot b/GI/Ggit/Objects/Signature.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Signature.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Signature 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 + +newtype Signature = Signature (ManagedPtr Signature) +instance GObject Signature where +class (GObject o, O.IsDescendantOf Signature o) => IsSignature o +instance (GObject o, O.IsDescendantOf Signature o) => IsSignature o +instance O.HasParentTypes Signature +#if ENABLE_OVERLOADING +data SignatureEncodingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SignatureCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SignatureGetEmailMethodInfo +#endif +#if ENABLE_OVERLOADING +data SignatureGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data SignatureGetTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SignatureGetTimeZoneMethodInfo +#endif diff --git a/GI/Ggit/Objects/SubmoduleUpdateOptions.hs b/GI/Ggit/Objects/SubmoduleUpdateOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/SubmoduleUpdateOptions.hs @@ -0,0 +1,507 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents options for a submodule update. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.SubmoduleUpdateOptions + ( + +-- * Exported types + SubmoduleUpdateOptions(..) , + IsSubmoduleUpdateOptions , + toSubmoduleUpdateOptions , + noSubmoduleUpdateOptions , + + + -- * Methods +-- ** getCheckoutOptions #method:getCheckoutOptions# + +#if ENABLE_OVERLOADING + SubmoduleUpdateOptionsGetCheckoutOptionsMethodInfo, +#endif + submoduleUpdateOptionsGetCheckoutOptions, + + +-- ** getFetchOptions #method:getFetchOptions# + +#if ENABLE_OVERLOADING + SubmoduleUpdateOptionsGetFetchOptionsMethodInfo, +#endif + submoduleUpdateOptionsGetFetchOptions , + + +-- ** new #method:new# + + submoduleUpdateOptionsNew , + + +-- ** setCheckoutOptions #method:setCheckoutOptions# + +#if ENABLE_OVERLOADING + SubmoduleUpdateOptionsSetCheckoutOptionsMethodInfo, +#endif + submoduleUpdateOptionsSetCheckoutOptions, + + +-- ** setFetchOptions #method:setFetchOptions# + +#if ENABLE_OVERLOADING + SubmoduleUpdateOptionsSetFetchOptionsMethodInfo, +#endif + submoduleUpdateOptionsSetFetchOptions , + + + + + -- * Properties +-- ** checkoutOptions #attr:checkoutOptions# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo, +#endif + clearSubmoduleUpdateOptionsCheckoutOptions, + constructSubmoduleUpdateOptionsCheckoutOptions, + getSubmoduleUpdateOptionsCheckoutOptions, + setSubmoduleUpdateOptionsCheckoutOptions, +#if ENABLE_OVERLOADING + submoduleUpdateOptionsCheckoutOptions , +#endif + + +-- ** fetchOptions #attr:fetchOptions# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + SubmoduleUpdateOptionsFetchOptionsPropertyInfo, +#endif + clearSubmoduleUpdateOptionsFetchOptions , + constructSubmoduleUpdateOptionsFetchOptions, + getSubmoduleUpdateOptionsFetchOptions , + setSubmoduleUpdateOptionsFetchOptions , +#if ENABLE_OVERLOADING + submoduleUpdateOptionsFetchOptions , +#endif + + + + + ) 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.Objects.CheckoutOptions as Ggit.CheckoutOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.FetchOptions as Ggit.FetchOptions + +-- | Memory-managed wrapper type. +newtype SubmoduleUpdateOptions = SubmoduleUpdateOptions (ManagedPtr SubmoduleUpdateOptions) +foreign import ccall "ggit_submodule_update_options_get_type" + c_ggit_submodule_update_options_get_type :: IO GType + +instance GObject SubmoduleUpdateOptions where + gobjectType = c_ggit_submodule_update_options_get_type + + +-- | Type class for types which can be safely cast to `SubmoduleUpdateOptions`, for instance with `toSubmoduleUpdateOptions`. +class (GObject o, O.IsDescendantOf SubmoduleUpdateOptions o) => IsSubmoduleUpdateOptions o +instance (GObject o, O.IsDescendantOf SubmoduleUpdateOptions o) => IsSubmoduleUpdateOptions o + +instance O.HasParentTypes SubmoduleUpdateOptions +type instance O.ParentTypes SubmoduleUpdateOptions = '[GObject.Object.Object] + +-- | Cast to `SubmoduleUpdateOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSubmoduleUpdateOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m SubmoduleUpdateOptions +toSubmoduleUpdateOptions = liftIO . unsafeCastTo SubmoduleUpdateOptions + +-- | A convenience alias for `Nothing` :: `Maybe` `SubmoduleUpdateOptions`. +noSubmoduleUpdateOptions :: Maybe SubmoduleUpdateOptions +noSubmoduleUpdateOptions = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSubmoduleUpdateOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveSubmoduleUpdateOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSubmoduleUpdateOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSubmoduleUpdateOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSubmoduleUpdateOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSubmoduleUpdateOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSubmoduleUpdateOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSubmoduleUpdateOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSubmoduleUpdateOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSubmoduleUpdateOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSubmoduleUpdateOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSubmoduleUpdateOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSubmoduleUpdateOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSubmoduleUpdateOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSubmoduleUpdateOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSubmoduleUpdateOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSubmoduleUpdateOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSubmoduleUpdateOptionsMethod "getCheckoutOptions" o = SubmoduleUpdateOptionsGetCheckoutOptionsMethodInfo + ResolveSubmoduleUpdateOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSubmoduleUpdateOptionsMethod "getFetchOptions" o = SubmoduleUpdateOptionsGetFetchOptionsMethodInfo + ResolveSubmoduleUpdateOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSubmoduleUpdateOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSubmoduleUpdateOptionsMethod "setCheckoutOptions" o = SubmoduleUpdateOptionsSetCheckoutOptionsMethodInfo + ResolveSubmoduleUpdateOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSubmoduleUpdateOptionsMethod "setFetchOptions" o = SubmoduleUpdateOptionsSetFetchOptionsMethodInfo + ResolveSubmoduleUpdateOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSubmoduleUpdateOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSubmoduleUpdateOptionsMethod t SubmoduleUpdateOptions, O.MethodInfo info SubmoduleUpdateOptions p) => OL.IsLabel t (SubmoduleUpdateOptions -> 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 + +-- VVV Prop "checkout-options" + -- Type: TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@checkout-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' submoduleUpdateOptions #checkoutOptions +@ +-} +getSubmoduleUpdateOptionsCheckoutOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m (Maybe Ggit.CheckoutOptions.CheckoutOptions) +getSubmoduleUpdateOptionsCheckoutOptions obj = liftIO $ B.Properties.getObjectPropertyObject obj "checkout-options" Ggit.CheckoutOptions.CheckoutOptions + +{- | +Set the value of the “@checkout-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' submoduleUpdateOptions [ #checkoutOptions 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSubmoduleUpdateOptionsCheckoutOptions :: (MonadIO m, IsSubmoduleUpdateOptions o, Ggit.CheckoutOptions.IsCheckoutOptions a) => o -> a -> m () +setSubmoduleUpdateOptionsCheckoutOptions obj val = liftIO $ B.Properties.setObjectPropertyObject obj "checkout-options" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@checkout-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSubmoduleUpdateOptionsCheckoutOptions :: (IsSubmoduleUpdateOptions o, Ggit.CheckoutOptions.IsCheckoutOptions a) => a -> IO (GValueConstruct o) +constructSubmoduleUpdateOptionsCheckoutOptions val = B.Properties.constructObjectPropertyObject "checkout-options" (Just val) + +{- | +Set the value of the “@checkout-options@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #checkoutOptions +@ +-} +clearSubmoduleUpdateOptionsCheckoutOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m () +clearSubmoduleUpdateOptionsCheckoutOptions obj = liftIO $ B.Properties.setObjectPropertyObject obj "checkout-options" (Nothing :: Maybe Ggit.CheckoutOptions.CheckoutOptions) + +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo +instance AttrInfo SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo where + type AttrAllowedOps SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo = Ggit.CheckoutOptions.IsCheckoutOptions + type AttrBaseTypeConstraint SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo = IsSubmoduleUpdateOptions + type AttrGetType SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo = (Maybe Ggit.CheckoutOptions.CheckoutOptions) + type AttrLabel SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo = "checkout-options" + type AttrOrigin SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo = SubmoduleUpdateOptions + attrGet _ = getSubmoduleUpdateOptionsCheckoutOptions + attrSet _ = setSubmoduleUpdateOptionsCheckoutOptions + attrConstruct _ = constructSubmoduleUpdateOptionsCheckoutOptions + attrClear _ = clearSubmoduleUpdateOptionsCheckoutOptions +#endif + +-- VVV Prop "fetch-options" + -- Type: TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@fetch-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' submoduleUpdateOptions #fetchOptions +@ +-} +getSubmoduleUpdateOptionsFetchOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m (Maybe Ggit.FetchOptions.FetchOptions) +getSubmoduleUpdateOptionsFetchOptions obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "fetch-options" Ggit.FetchOptions.FetchOptions + +{- | +Set the value of the “@fetch-options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' submoduleUpdateOptions [ #fetchOptions 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSubmoduleUpdateOptionsFetchOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> Ggit.FetchOptions.FetchOptions -> m () +setSubmoduleUpdateOptionsFetchOptions obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "fetch-options" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@fetch-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSubmoduleUpdateOptionsFetchOptions :: (IsSubmoduleUpdateOptions o) => Ggit.FetchOptions.FetchOptions -> IO (GValueConstruct o) +constructSubmoduleUpdateOptionsFetchOptions val = B.Properties.constructObjectPropertyBoxed "fetch-options" (Just val) + +{- | +Set the value of the “@fetch-options@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #fetchOptions +@ +-} +clearSubmoduleUpdateOptionsFetchOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m () +clearSubmoduleUpdateOptionsFetchOptions obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "fetch-options" (Nothing :: Maybe Ggit.FetchOptions.FetchOptions) + +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsFetchOptionsPropertyInfo +instance AttrInfo SubmoduleUpdateOptionsFetchOptionsPropertyInfo where + type AttrAllowedOps SubmoduleUpdateOptionsFetchOptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SubmoduleUpdateOptionsFetchOptionsPropertyInfo = (~) Ggit.FetchOptions.FetchOptions + type AttrBaseTypeConstraint SubmoduleUpdateOptionsFetchOptionsPropertyInfo = IsSubmoduleUpdateOptions + type AttrGetType SubmoduleUpdateOptionsFetchOptionsPropertyInfo = (Maybe Ggit.FetchOptions.FetchOptions) + type AttrLabel SubmoduleUpdateOptionsFetchOptionsPropertyInfo = "fetch-options" + type AttrOrigin SubmoduleUpdateOptionsFetchOptionsPropertyInfo = SubmoduleUpdateOptions + attrGet _ = getSubmoduleUpdateOptionsFetchOptions + attrSet _ = setSubmoduleUpdateOptionsFetchOptions + attrConstruct _ = constructSubmoduleUpdateOptionsFetchOptions + attrClear _ = clearSubmoduleUpdateOptionsFetchOptions +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SubmoduleUpdateOptions +type instance O.AttributeList SubmoduleUpdateOptions = SubmoduleUpdateOptionsAttributeList +type SubmoduleUpdateOptionsAttributeList = ('[ '("checkoutOptions", SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo), '("fetchOptions", SubmoduleUpdateOptionsFetchOptionsPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +submoduleUpdateOptionsCheckoutOptions :: AttrLabelProxy "checkoutOptions" +submoduleUpdateOptionsCheckoutOptions = AttrLabelProxy + +submoduleUpdateOptionsFetchOptions :: AttrLabelProxy "fetchOptions" +submoduleUpdateOptionsFetchOptions = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList SubmoduleUpdateOptions = SubmoduleUpdateOptionsSignalList +type SubmoduleUpdateOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method SubmoduleUpdateOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_update_options_new" ggit_submodule_update_options_new :: + IO (Ptr SubmoduleUpdateOptions) + +{- | +Creates a new submodule options object. +-} +submoduleUpdateOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Maybe SubmoduleUpdateOptions) + {- ^ __Returns:__ a 'GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions' or 'Nothing'. -} +submoduleUpdateOptionsNew = liftIO $ do + result <- ggit_submodule_update_options_new + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject SubmoduleUpdateOptions) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method SubmoduleUpdateOptions::get_checkout_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmoduleUpdateOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_update_options_get_checkout_options" ggit_submodule_update_options_get_checkout_options :: + Ptr SubmoduleUpdateOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}) + IO (Ptr Ggit.CheckoutOptions.CheckoutOptions) + +{- | +Get the checkout options. +-} +submoduleUpdateOptionsGetCheckoutOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions'. -} + -> m (Maybe Ggit.CheckoutOptions.CheckoutOptions) + {- ^ __Returns:__ a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions' or 'Nothing'. -} +submoduleUpdateOptionsGetCheckoutOptions options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_submodule_update_options_get_checkout_options options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.CheckoutOptions.CheckoutOptions) result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsGetCheckoutOptionsMethodInfo +instance (signature ~ (m (Maybe Ggit.CheckoutOptions.CheckoutOptions)), MonadIO m, IsSubmoduleUpdateOptions a) => O.MethodInfo SubmoduleUpdateOptionsGetCheckoutOptionsMethodInfo a signature where + overloadedMethod _ = submoduleUpdateOptionsGetCheckoutOptions + +#endif + +-- method SubmoduleUpdateOptions::get_fetch_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "FetchOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_update_options_get_fetch_options" ggit_submodule_update_options_get_fetch_options :: + Ptr SubmoduleUpdateOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}) + IO (Ptr Ggit.FetchOptions.FetchOptions) + +{- | +/No description available in the introspection data./ +-} +submoduleUpdateOptionsGetFetchOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a) => + a + -> m Ggit.FetchOptions.FetchOptions +submoduleUpdateOptionsGetFetchOptions options = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + result <- ggit_submodule_update_options_get_fetch_options options' + checkUnexpectedReturnNULL "submoduleUpdateOptionsGetFetchOptions" result + result' <- (wrapBoxed Ggit.FetchOptions.FetchOptions) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsGetFetchOptionsMethodInfo +instance (signature ~ (m Ggit.FetchOptions.FetchOptions), MonadIO m, IsSubmoduleUpdateOptions a) => O.MethodInfo SubmoduleUpdateOptionsGetFetchOptionsMethodInfo a signature where + overloadedMethod _ = submoduleUpdateOptionsGetFetchOptions + +#endif + +-- method SubmoduleUpdateOptions::set_checkout_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmoduleUpdateOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checkout_options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_update_options_set_checkout_options" ggit_submodule_update_options_set_checkout_options :: + Ptr SubmoduleUpdateOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- checkout_options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO () + +{- | +Set the checkout options. +-} +submoduleUpdateOptionsSetCheckoutOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a, Ggit.CheckoutOptions.IsCheckoutOptions b) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions'. -} + -> Maybe (b) + {- ^ /@checkoutOptions@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m () +submoduleUpdateOptionsSetCheckoutOptions options checkoutOptions = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeCheckoutOptions <- case checkoutOptions of + Nothing -> return nullPtr + Just jCheckoutOptions -> do + jCheckoutOptions' <- unsafeManagedPtrCastPtr jCheckoutOptions + return jCheckoutOptions' + ggit_submodule_update_options_set_checkout_options options' maybeCheckoutOptions + touchManagedPtr options + whenJust checkoutOptions touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsSetCheckoutOptionsMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSubmoduleUpdateOptions a, Ggit.CheckoutOptions.IsCheckoutOptions b) => O.MethodInfo SubmoduleUpdateOptionsSetCheckoutOptionsMethodInfo a signature where + overloadedMethod _ = submoduleUpdateOptionsSetCheckoutOptions + +#endif + +-- method SubmoduleUpdateOptions::set_fetch_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmoduleUpdateOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fetch_options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_update_options_set_fetch_options" ggit_submodule_update_options_set_fetch_options :: + Ptr SubmoduleUpdateOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}) + Ptr Ggit.FetchOptions.FetchOptions -> -- fetch_options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + IO () + +{- | +Sets the fetch options. +-} +submoduleUpdateOptionsSetFetchOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a) => + a + {- ^ /@options@/: a 'GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions'. -} + -> Maybe (Ggit.FetchOptions.FetchOptions) + {- ^ /@fetchOptions@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> m () +submoduleUpdateOptionsSetFetchOptions options fetchOptions = liftIO $ do + options' <- unsafeManagedPtrCastPtr options + maybeFetchOptions <- case fetchOptions of + Nothing -> return nullPtr + Just jFetchOptions -> do + jFetchOptions' <- unsafeManagedPtrGetPtr jFetchOptions + return jFetchOptions' + ggit_submodule_update_options_set_fetch_options options' maybeFetchOptions + touchManagedPtr options + whenJust fetchOptions touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsSetFetchOptionsMethodInfo +instance (signature ~ (Maybe (Ggit.FetchOptions.FetchOptions) -> m ()), MonadIO m, IsSubmoduleUpdateOptions a) => O.MethodInfo SubmoduleUpdateOptionsSetFetchOptionsMethodInfo a signature where + overloadedMethod _ = submoduleUpdateOptionsSetFetchOptions + +#endif + + diff --git a/GI/Ggit/Objects/SubmoduleUpdateOptions.hs-boot b/GI/Ggit/Objects/SubmoduleUpdateOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/SubmoduleUpdateOptions.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.SubmoduleUpdateOptions 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 + +newtype SubmoduleUpdateOptions = SubmoduleUpdateOptions (ManagedPtr SubmoduleUpdateOptions) +instance GObject SubmoduleUpdateOptions where +class (GObject o, O.IsDescendantOf SubmoduleUpdateOptions o) => IsSubmoduleUpdateOptions o +instance (GObject o, O.IsDescendantOf SubmoduleUpdateOptions o) => IsSubmoduleUpdateOptions o +instance O.HasParentTypes SubmoduleUpdateOptions +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsCheckoutOptionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsFetchOptionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsGetCheckoutOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsGetFetchOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsSetCheckoutOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleUpdateOptionsSetFetchOptionsMethodInfo +#endif diff --git a/GI/Ggit/Objects/Tag.hs b/GI/Ggit/Objects/Tag.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Tag.hs @@ -0,0 +1,465 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a tag object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Tag + ( + +-- * Exported types + Tag(..) , + IsTag , + toTag , + noTag , + + + -- * Methods +-- ** getMessage #method:getMessage# + +#if ENABLE_OVERLOADING + TagGetMessageMethodInfo , +#endif + tagGetMessage , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + TagGetNameMethodInfo , +#endif + tagGetName , + + +-- ** getTagger #method:getTagger# + +#if ENABLE_OVERLOADING + TagGetTaggerMethodInfo , +#endif + tagGetTagger , + + +-- ** getTarget #method:getTarget# + +#if ENABLE_OVERLOADING + TagGetTargetMethodInfo , +#endif + tagGetTarget , + + +-- ** getTargetId #method:getTargetId# + +#if ENABLE_OVERLOADING + TagGetTargetIdMethodInfo , +#endif + tagGetTargetId , + + +-- ** getTargetType #method:getTargetType# + +#if ENABLE_OVERLOADING + TagGetTargetTypeMethodInfo , +#endif + tagGetTargetType , + + +-- ** peel #method:peel# + +#if ENABLE_OVERLOADING + TagPeelMethodInfo , +#endif + tagPeel , + + + + + ) 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.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype Tag = Tag (ManagedPtr Tag) +foreign import ccall "ggit_tag_get_type" + c_ggit_tag_get_type :: IO GType + +instance GObject Tag where + gobjectType = c_ggit_tag_get_type + + +-- | Type class for types which can be safely cast to `Tag`, for instance with `toTag`. +class (GObject o, O.IsDescendantOf Tag o) => IsTag o +instance (GObject o, O.IsDescendantOf Tag o) => IsTag o + +instance O.HasParentTypes Tag +type instance O.ParentTypes Tag = '[Ggit.Object.Object, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Tag`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toTag :: (MonadIO m, IsTag o) => o -> m Tag +toTag = liftIO . unsafeCastTo Tag + +-- | A convenience alias for `Nothing` :: `Maybe` `Tag`. +noTag :: Maybe Tag +noTag = Nothing + +#if ENABLE_OVERLOADING +type family ResolveTagMethod (t :: Symbol) (o :: *) :: * where + ResolveTagMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveTagMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveTagMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveTagMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveTagMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveTagMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveTagMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveTagMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveTagMethod "peel" o = TagPeelMethodInfo + ResolveTagMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveTagMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveTagMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveTagMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveTagMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveTagMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveTagMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveTagMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveTagMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveTagMethod "getId" o = Ggit.Object.ObjectGetIdMethodInfo + ResolveTagMethod "getMessage" o = TagGetMessageMethodInfo + ResolveTagMethod "getName" o = TagGetNameMethodInfo + ResolveTagMethod "getOwner" o = Ggit.Object.ObjectGetOwnerMethodInfo + ResolveTagMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveTagMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveTagMethod "getTagger" o = TagGetTaggerMethodInfo + ResolveTagMethod "getTarget" o = TagGetTargetMethodInfo + ResolveTagMethod "getTargetId" o = TagGetTargetIdMethodInfo + ResolveTagMethod "getTargetType" o = TagGetTargetTypeMethodInfo + ResolveTagMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveTagMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveTagMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTagMethod t Tag, O.MethodInfo info Tag p) => OL.IsLabel t (Tag -> 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 Tag +type instance O.AttributeList Tag = TagAttributeList +type TagAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Tag = TagSignalList +type TagSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Tag::get_message +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tag", argType = TInterface (Name {namespace = "Ggit", name = "Tag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tag_get_message" ggit_tag_get_message :: + Ptr Tag -> -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"}) + IO CString + +{- | +Gets the message of /@tag@/. +-} +tagGetMessage :: + (B.CallStack.HasCallStack, MonadIO m, IsTag a) => + a + {- ^ /@tag@/: a 'GI.Ggit.Objects.Tag.Tag'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the message of the tag or 'Nothing'. -} +tagGetMessage tag = liftIO $ do + tag' <- unsafeManagedPtrCastPtr tag + result <- ggit_tag_get_message tag' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr tag + return maybeResult + +#if ENABLE_OVERLOADING +data TagGetMessageMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTag a) => O.MethodInfo TagGetMessageMethodInfo a signature where + overloadedMethod _ = tagGetMessage + +#endif + +-- method Tag::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tag", argType = TInterface (Name {namespace = "Ggit", name = "Tag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tag_get_name" ggit_tag_get_name :: + Ptr Tag -> -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"}) + IO CString + +{- | +Gets the name of /@tag@/. +-} +tagGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsTag a) => + a + {- ^ /@tag@/: a 'GI.Ggit.Objects.Tag.Tag'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of the tag or 'Nothing'. -} +tagGetName tag = liftIO $ do + tag' <- unsafeManagedPtrCastPtr tag + result <- ggit_tag_get_name tag' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr tag + return maybeResult + +#if ENABLE_OVERLOADING +data TagGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTag a) => O.MethodInfo TagGetNameMethodInfo a signature where + overloadedMethod _ = tagGetName + +#endif + +-- method Tag::get_tagger +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tag", argType = TInterface (Name {namespace = "Ggit", name = "Tag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tag_get_tagger" ggit_tag_get_tagger :: + Ptr Tag -> -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"}) + IO (Ptr Ggit.Signature.Signature) + +{- | +Get the tagger (author) of /@tag@/. The returned value must be free with +'GI.GObject.Objects.Object.objectUnref'. +-} +tagGetTagger :: + (B.CallStack.HasCallStack, MonadIO m, IsTag a) => + a + {- ^ /@tag@/: a 'GI.Ggit.Objects.Tag.Tag'. -} + -> m (Maybe Ggit.Signature.Signature) + {- ^ __Returns:__ the tagger (author) of the tag or 'Nothing'. -} +tagGetTagger tag = liftIO $ do + tag' <- unsafeManagedPtrCastPtr tag + result <- ggit_tag_get_tagger tag' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Signature.Signature) result' + return result'' + touchManagedPtr tag + return maybeResult + +#if ENABLE_OVERLOADING +data TagGetTaggerMethodInfo +instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsTag a) => O.MethodInfo TagGetTaggerMethodInfo a signature where + overloadedMethod _ = tagGetTagger + +#endif + +-- method Tag::get_target +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tag", argType = TInterface (Name {namespace = "Ggit", name = "Tag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Object"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_tag_get_target" ggit_tag_get_target :: + Ptr Tag -> -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Object.Object) + +{- | +Gets the target 'GI.Ggit.Objects.Object.Object' of /@tag@/. + +This method performs a repository lookup for the +given object and returns it. +-} +tagGetTarget :: + (B.CallStack.HasCallStack, MonadIO m, IsTag a) => + a + {- ^ /@tag@/: a 'GI.Ggit.Objects.Tag.Tag'. -} + -> m (Maybe Ggit.Object.Object) + {- ^ __Returns:__ the target 'GI.Ggit.Objects.Object.Object' of the tag or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +tagGetTarget tag = liftIO $ do + tag' <- unsafeManagedPtrCastPtr tag + onException (do + result <- propagateGError $ ggit_tag_get_target tag' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Object.Object) result' + return result'' + touchManagedPtr tag + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data TagGetTargetMethodInfo +instance (signature ~ (m (Maybe Ggit.Object.Object)), MonadIO m, IsTag a) => O.MethodInfo TagGetTargetMethodInfo a signature where + overloadedMethod _ = tagGetTarget + +#endif + +-- method Tag::get_target_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tag", argType = TInterface (Name {namespace = "Ggit", name = "Tag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tag_get_target_id" ggit_tag_get_target_id :: + Ptr Tag -> -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the target 'GI.Ggit.Structs.OId.OId' of /@tag@/. +-} +tagGetTargetId :: + (B.CallStack.HasCallStack, MonadIO m, IsTag a) => + a + {- ^ /@tag@/: a 'GI.Ggit.Objects.Tag.Tag'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the target 'GI.Ggit.Structs.OId.OId' of the tag or 'Nothing'. -} +tagGetTargetId tag = liftIO $ do + tag' <- unsafeManagedPtrCastPtr tag + result <- ggit_tag_get_target_id tag' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr tag + return maybeResult + +#if ENABLE_OVERLOADING +data TagGetTargetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsTag a) => O.MethodInfo TagGetTargetIdMethodInfo a signature where + overloadedMethod _ = tagGetTargetId + +#endif + +-- method Tag::get_target_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tag", argType = TInterface (Name {namespace = "Ggit", name = "Tag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tag_get_target_type" ggit_tag_get_target_type :: + Ptr Tag -> -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"}) + IO CGType + +{- | +Get the target object type. +-} +tagGetTargetType :: + (B.CallStack.HasCallStack, MonadIO m, IsTag a) => + a + {- ^ /@tag@/: a 'GI.Ggit.Objects.Tag.Tag'. -} + -> m GType + {- ^ __Returns:__ a 'GType'. -} +tagGetTargetType tag = liftIO $ do + tag' <- unsafeManagedPtrCastPtr tag + result <- ggit_tag_get_target_type tag' + let result' = GType result + touchManagedPtr tag + return result' + +#if ENABLE_OVERLOADING +data TagGetTargetTypeMethodInfo +instance (signature ~ (m GType), MonadIO m, IsTag a) => O.MethodInfo TagGetTargetTypeMethodInfo a signature where + overloadedMethod _ = tagGetTargetType + +#endif + +-- method Tag::peel +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tag", argType = TInterface (Name {namespace = "Ggit", name = "Tag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTag.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Object"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_tag_peel" ggit_tag_peel :: + Ptr Tag -> -- tag : TInterface (Name {namespace = "Ggit", name = "Tag"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Object.Object) + +{- | +Recursively peel a tag until a non tag object is found. +-} +tagPeel :: + (B.CallStack.HasCallStack, MonadIO m, IsTag a) => + a + {- ^ /@tag@/: a 'GI.Ggit.Objects.Tag.Tag'. -} + -> m (Maybe Ggit.Object.Object) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Object.Object' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +tagPeel tag = liftIO $ do + tag' <- unsafeManagedPtrCastPtr tag + onException (do + result <- propagateGError $ ggit_tag_peel tag' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Object.Object) result' + return result'' + touchManagedPtr tag + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data TagPeelMethodInfo +instance (signature ~ (m (Maybe Ggit.Object.Object)), MonadIO m, IsTag a) => O.MethodInfo TagPeelMethodInfo a signature where + overloadedMethod _ = tagPeel + +#endif + + diff --git a/GI/Ggit/Objects/Tag.hs-boot b/GI/Ggit/Objects/Tag.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Tag.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Tag 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 + +newtype Tag = Tag (ManagedPtr Tag) +instance GObject Tag where +class (GObject o, O.IsDescendantOf Tag o) => IsTag o +instance (GObject o, O.IsDescendantOf Tag o) => IsTag o +instance O.HasParentTypes Tag +#if ENABLE_OVERLOADING +data TagGetMessageMethodInfo +#endif +#if ENABLE_OVERLOADING +data TagGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data TagGetTaggerMethodInfo +#endif +#if ENABLE_OVERLOADING +data TagGetTargetMethodInfo +#endif +#if ENABLE_OVERLOADING +data TagGetTargetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data TagGetTargetTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TagPeelMethodInfo +#endif diff --git a/GI/Ggit/Objects/Tree.hs b/GI/Ggit/Objects/Tree.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Tree.hs @@ -0,0 +1,440 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a tree object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.Tree + ( + +-- * Exported types + Tree(..) , + IsTree , + toTree , + noTree , + + + -- * Methods +-- ** get #method:get# + +#if ENABLE_OVERLOADING + TreeGetMethodInfo , +#endif + treeGet , + + +-- ** getByName #method:getByName# + +#if ENABLE_OVERLOADING + TreeGetByNameMethodInfo , +#endif + treeGetByName , + + +-- ** getByPath #method:getByPath# + +#if ENABLE_OVERLOADING + TreeGetByPathMethodInfo , +#endif + treeGetByPath , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + TreeGetIdMethodInfo , +#endif + treeGetId , + + +-- ** size #method:size# + +#if ENABLE_OVERLOADING + TreeSizeMethodInfo , +#endif + treeSize , + + +-- ** walk #method:walk# + +#if ENABLE_OVERLOADING + TreeWalkMethodInfo , +#endif + treeWalk , + + + + + ) 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 qualified GI.Ggit.Callbacks as Ggit.Callbacks +import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native +import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object +import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.TreeEntry as Ggit.TreeEntry + +-- | Memory-managed wrapper type. +newtype Tree = Tree (ManagedPtr Tree) +foreign import ccall "ggit_tree_get_type" + c_ggit_tree_get_type :: IO GType + +instance GObject Tree where + gobjectType = c_ggit_tree_get_type + + +-- | Type class for types which can be safely cast to `Tree`, for instance with `toTree`. +class (GObject o, O.IsDescendantOf Tree o) => IsTree o +instance (GObject o, O.IsDescendantOf Tree o) => IsTree o + +instance O.HasParentTypes Tree +type instance O.ParentTypes Tree = '[Ggit.Object.Object, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `Tree`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toTree :: (MonadIO m, IsTree o) => o -> m Tree +toTree = liftIO . unsafeCastTo Tree + +-- | A convenience alias for `Nothing` :: `Maybe` `Tree`. +noTree :: Maybe Tree +noTree = Nothing + +#if ENABLE_OVERLOADING +type family ResolveTreeMethod (t :: Symbol) (o :: *) :: * where + ResolveTreeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveTreeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveTreeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveTreeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveTreeMethod "get" o = TreeGetMethodInfo + ResolveTreeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveTreeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveTreeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveTreeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveTreeMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveTreeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveTreeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveTreeMethod "size" o = TreeSizeMethodInfo + ResolveTreeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveTreeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveTreeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveTreeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveTreeMethod "walk" o = TreeWalkMethodInfo + ResolveTreeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveTreeMethod "getByName" o = TreeGetByNameMethodInfo + ResolveTreeMethod "getByPath" o = TreeGetByPathMethodInfo + ResolveTreeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveTreeMethod "getId" o = TreeGetIdMethodInfo + ResolveTreeMethod "getOwner" o = Ggit.Object.ObjectGetOwnerMethodInfo + ResolveTreeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveTreeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveTreeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveTreeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveTreeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTreeMethod t Tree, O.MethodInfo info Tree p) => OL.IsLabel t (Tree -> 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 Tree +type instance O.AttributeList Tree = TreeAttributeList +type TreeAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Tree = TreeSignalList +type TreeSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Tree::get +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the entry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_get" ggit_tree_get :: + Ptr Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + Word32 -> -- i : TBasicType TUInt + IO (Ptr Ggit.TreeEntry.TreeEntry) + +{- | +Get a tree entry by index. +-} +treeGet :: + (B.CallStack.HasCallStack, MonadIO m, IsTree a) => + a + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> Word32 + {- ^ /@i@/: the index of the entry. -} + -> m (Maybe Ggit.TreeEntry.TreeEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. -} +treeGet tree i = liftIO $ do + tree' <- unsafeManagedPtrCastPtr tree + result <- ggit_tree_get tree' i + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result' + return result'' + touchManagedPtr tree + return maybeResult + +#if ENABLE_OVERLOADING +data TreeGetMethodInfo +instance (signature ~ (Word32 -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTree a) => O.MethodInfo TreeGetMethodInfo a signature where + overloadedMethod _ = treeGet + +#endif + +-- method Tree::get_by_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a filename.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_get_by_name" ggit_tree_get_by_name :: + Ptr Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr Ggit.TreeEntry.TreeEntry) + +{- | +Get a tree entry by name. +-} +treeGetByName :: + (B.CallStack.HasCallStack, MonadIO m, IsTree a) => + a + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> T.Text + {- ^ /@name@/: a filename. -} + -> m (Maybe Ggit.TreeEntry.TreeEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. -} +treeGetByName tree name = liftIO $ do + tree' <- unsafeManagedPtrCastPtr tree + name' <- textToCString name + result <- ggit_tree_get_by_name tree' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result' + return result'' + touchManagedPtr tree + freeMem name' + return maybeResult + +#if ENABLE_OVERLOADING +data TreeGetByNameMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTree a) => O.MethodInfo TreeGetByNameMethodInfo a signature where + overloadedMethod _ = treeGetByName + +#endif + +-- method Tree::get_by_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeEntry"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_tree_get_by_path" ggit_tree_get_by_path :: + Ptr Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + CString -> -- path : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.TreeEntry.TreeEntry) + +{- | +Retrieves a tree entry contained in a tree or in any of its subtrees, +given its relative path. +-} +treeGetByPath :: + (B.CallStack.HasCallStack, MonadIO m, IsTree a) => + a + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> T.Text + {- ^ /@path@/: a path. -} + -> m (Maybe Ggit.TreeEntry.TreeEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +treeGetByPath tree path = liftIO $ do + tree' <- unsafeManagedPtrCastPtr tree + path' <- textToCString path + onException (do + result <- propagateGError $ ggit_tree_get_by_path tree' path' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result' + return result'' + touchManagedPtr tree + freeMem path' + return maybeResult + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data TreeGetByPathMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTree a) => O.MethodInfo TreeGetByPathMethodInfo a signature where + overloadedMethod _ = treeGetByPath + +#endif + +-- method Tree::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_get_id" ggit_tree_get_id :: + Ptr Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the 'GI.Ggit.Structs.OId.OId' of the tree. +-} +treeGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsTree a) => + a + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +treeGetId tree = liftIO $ do + tree' <- unsafeManagedPtrCastPtr tree + result <- ggit_tree_get_id tree' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr tree + return maybeResult + +#if ENABLE_OVERLOADING +data TreeGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsTree a) => O.MethodInfo TreeGetIdMethodInfo a signature where + overloadedMethod _ = treeGetId + +#endif + +-- method Tree::size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_size" ggit_tree_size :: + Ptr Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + IO Word32 + +{- | +Get the number of entries in the tree. +-} +treeSize :: + (B.CallStack.HasCallStack, MonadIO m, IsTree a) => + a + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> m Word32 + {- ^ __Returns:__ the number of entries in the tree. -} +treeSize tree = liftIO $ do + tree' <- unsafeManagedPtrCastPtr tree + result <- ggit_tree_size tree' + touchManagedPtr tree + return result + +#if ENABLE_OVERLOADING +data TreeSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsTree a) => O.MethodInfo TreeSizeMethodInfo a signature where + overloadedMethod _ = treeSize + +#endif + +-- method Tree::walk +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Ggit", name = "TreeWalkMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the walking order.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "TreeWalkCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the callback to call for each entry.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for the callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_tree_walk" ggit_tree_walk :: + Ptr Tree -> -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"}) + CUInt -> -- mode : TInterface (Name {namespace = "Ggit", name = "TreeWalkMode"}) + FunPtr Ggit.Callbacks.C_TreeWalkCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "TreeWalkCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO () + +{- | +Walk all the entries of a tree object recursively (resolving and walking +subtrees of the tree as needed). The /@error@/ will be set to the error returned +by /@callback@/ (if any). +-} +treeWalk :: + (B.CallStack.HasCallStack, MonadIO m, IsTree a) => + a + {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -} + -> Ggit.Enums.TreeWalkMode + {- ^ /@mode@/: the walking order. -} + -> Ggit.Callbacks.TreeWalkCallback + {- ^ /@callback@/: the callback to call for each entry. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +treeWalk tree mode callback = liftIO $ do + tree' <- unsafeManagedPtrCastPtr tree + let mode' = (fromIntegral . fromEnum) mode + callback' <- Ggit.Callbacks.mk_TreeWalkCallback (Ggit.Callbacks.wrap_TreeWalkCallback Nothing (Ggit.Callbacks.drop_closures_TreeWalkCallback callback)) + let userData = nullPtr + onException (do + propagateGError $ ggit_tree_walk tree' mode' callback' userData + safeFreeFunPtr $ castFunPtrToPtr callback' + touchManagedPtr tree + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback' + return () + ) + +#if ENABLE_OVERLOADING +data TreeWalkMethodInfo +instance (signature ~ (Ggit.Enums.TreeWalkMode -> Ggit.Callbacks.TreeWalkCallback -> m ()), MonadIO m, IsTree a) => O.MethodInfo TreeWalkMethodInfo a signature where + overloadedMethod _ = treeWalk + +#endif + + diff --git a/GI/Ggit/Objects/Tree.hs-boot b/GI/Ggit/Objects/Tree.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/Tree.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.Tree 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 + +newtype Tree = Tree (ManagedPtr Tree) +instance GObject Tree where +class (GObject o, O.IsDescendantOf Tree o) => IsTree o +instance (GObject o, O.IsDescendantOf Tree o) => IsTree o +instance O.HasParentTypes Tree +#if ENABLE_OVERLOADING +data TreeGetMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeGetByNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeGetByPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeWalkMethodInfo +#endif diff --git a/GI/Ggit/Objects/TreeBuilder.hs b/GI/Ggit/Objects/TreeBuilder.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/TreeBuilder.hs @@ -0,0 +1,396 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a tree object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Objects.TreeBuilder + ( + +-- * Exported types + TreeBuilder(..) , + IsTreeBuilder , + toTreeBuilder , + noTreeBuilder , + + + -- * Methods +-- ** clear #method:clear# + +#if ENABLE_OVERLOADING + TreeBuilderClearMethodInfo , +#endif + treeBuilderClear , + + +-- ** getEntry #method:getEntry# + +#if ENABLE_OVERLOADING + TreeBuilderGetEntryMethodInfo , +#endif + treeBuilderGetEntry , + + +-- ** insert #method:insert# + +#if ENABLE_OVERLOADING + TreeBuilderInsertMethodInfo , +#endif + treeBuilderInsert , + + +-- ** remove #method:remove# + +#if ENABLE_OVERLOADING + TreeBuilderRemoveMethodInfo , +#endif + treeBuilderRemove , + + +-- ** write #method:write# + +#if ENABLE_OVERLOADING + TreeBuilderWriteMethodInfo , +#endif + treeBuilderWrite , + + + + + ) 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.Enums as Ggit.Enums +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.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.TreeEntry as Ggit.TreeEntry + +-- | Memory-managed wrapper type. +newtype TreeBuilder = TreeBuilder (ManagedPtr TreeBuilder) +foreign import ccall "ggit_tree_builder_get_type" + c_ggit_tree_builder_get_type :: IO GType + +instance GObject TreeBuilder where + gobjectType = c_ggit_tree_builder_get_type + + +-- | Type class for types which can be safely cast to `TreeBuilder`, for instance with `toTreeBuilder`. +class (GObject o, O.IsDescendantOf TreeBuilder o) => IsTreeBuilder o +instance (GObject o, O.IsDescendantOf TreeBuilder o) => IsTreeBuilder o + +instance O.HasParentTypes TreeBuilder +type instance O.ParentTypes TreeBuilder = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object] + +-- | Cast to `TreeBuilder`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toTreeBuilder :: (MonadIO m, IsTreeBuilder o) => o -> m TreeBuilder +toTreeBuilder = liftIO . unsafeCastTo TreeBuilder + +-- | A convenience alias for `Nothing` :: `Maybe` `TreeBuilder`. +noTreeBuilder :: Maybe TreeBuilder +noTreeBuilder = Nothing + +#if ENABLE_OVERLOADING +type family ResolveTreeBuilderMethod (t :: Symbol) (o :: *) :: * where + ResolveTreeBuilderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveTreeBuilderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveTreeBuilderMethod "clear" o = TreeBuilderClearMethodInfo + ResolveTreeBuilderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveTreeBuilderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveTreeBuilderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveTreeBuilderMethod "insert" o = TreeBuilderInsertMethodInfo + ResolveTreeBuilderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveTreeBuilderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveTreeBuilderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveTreeBuilderMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveTreeBuilderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveTreeBuilderMethod "remove" o = TreeBuilderRemoveMethodInfo + ResolveTreeBuilderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveTreeBuilderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveTreeBuilderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveTreeBuilderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveTreeBuilderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveTreeBuilderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveTreeBuilderMethod "write" o = TreeBuilderWriteMethodInfo + ResolveTreeBuilderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveTreeBuilderMethod "getEntry" o = TreeBuilderGetEntryMethodInfo + ResolveTreeBuilderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveTreeBuilderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveTreeBuilderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveTreeBuilderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveTreeBuilderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTreeBuilderMethod t TreeBuilder, O.MethodInfo info TreeBuilder p) => OL.IsLabel t (TreeBuilder -> 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 TreeBuilder +type instance O.AttributeList TreeBuilder = TreeBuilderAttributeList +type TreeBuilderAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList TreeBuilder = TreeBuilderSignalList +type TreeBuilderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method TreeBuilder::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "builder", argType = TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeBuilder.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_builder_clear" ggit_tree_builder_clear :: + Ptr TreeBuilder -> -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}) + IO () + +{- | +Clear all entries in the tree builder. +-} +treeBuilderClear :: + (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) => + a + {- ^ /@builder@/: a 'GI.Ggit.Objects.TreeBuilder.TreeBuilder'. -} + -> m () +treeBuilderClear builder = liftIO $ do + builder' <- unsafeManagedPtrCastPtr builder + ggit_tree_builder_clear builder' + touchManagedPtr builder + return () + +#if ENABLE_OVERLOADING +data TreeBuilderClearMethodInfo +instance (signature ~ (m ()), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderClearMethodInfo a signature where + overloadedMethod _ = treeBuilderClear + +#endif + +-- method TreeBuilder::get_entry +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "builder", argType = TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeBuilder.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path to remove.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_builder_get_entry" ggit_tree_builder_get_entry :: + Ptr TreeBuilder -> -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}) + CString -> -- path : TBasicType TUTF8 + IO (Ptr Ggit.TreeEntry.TreeEntry) + +{- | +Get an entry by path. +-} +treeBuilderGetEntry :: + (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) => + a + {- ^ /@builder@/: a 'GI.Ggit.Objects.TreeBuilder.TreeBuilder'. -} + -> T.Text + {- ^ /@path@/: the path to remove. -} + -> m (Maybe Ggit.TreeEntry.TreeEntry) + {- ^ __Returns:__ the @/GGitTreeEntry/@ or 'Nothing' if no such entry exists. -} +treeBuilderGetEntry builder path = liftIO $ do + builder' <- unsafeManagedPtrCastPtr builder + path' <- textToCString path + result <- ggit_tree_builder_get_entry builder' path' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result' + return result'' + touchManagedPtr builder + freeMem path' + return maybeResult + +#if ENABLE_OVERLOADING +data TreeBuilderGetEntryMethodInfo +instance (signature ~ (T.Text -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderGetEntryMethodInfo a signature where + overloadedMethod _ = treeBuilderGetEntry + +#endif + +-- method TreeBuilder::insert +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "builder", argType = TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeBuilder.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GgitOId of the file blob to insert.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_mode", argType = TInterface (Name {namespace = "Ggit", name = "FileMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFileMode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeEntry"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_tree_builder_insert" ggit_tree_builder_insert :: + Ptr TreeBuilder -> -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}) + CString -> -- filename : TBasicType TUTF8 + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + CUInt -> -- file_mode : TInterface (Name {namespace = "Ggit", name = "FileMode"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.TreeEntry.TreeEntry) + +{- | +Insert a file with a given blob in the tree builder. If the tree builder +already contains an entry for the given file, then this entry will be +overwritten. + +Note that the returned 'GI.Ggit.Structs.TreeEntry.TreeEntry' is bound to the lifetime of the tree +builder and cannot be used after the tree builder has been freed. +-} +treeBuilderInsert :: + (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) => + a + {- ^ /@builder@/: a 'GI.Ggit.Objects.TreeBuilder.TreeBuilder'. -} + -> T.Text + {- ^ /@filename@/: the file name. -} + -> Ggit.OId.OId + {- ^ /@oid@/: the 'GI.Ggit.Structs.OId.OId' of the file blob to insert. -} + -> Ggit.Enums.FileMode + {- ^ /@fileMode@/: a 'GI.Ggit.Enums.FileMode'. -} + -> m (Maybe Ggit.TreeEntry.TreeEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +treeBuilderInsert builder filename oid fileMode = liftIO $ do + builder' <- unsafeManagedPtrCastPtr builder + filename' <- textToCString filename + oid' <- unsafeManagedPtrGetPtr oid + let fileMode' = (fromIntegral . fromEnum) fileMode + onException (do + result <- propagateGError $ ggit_tree_builder_insert builder' filename' oid' fileMode' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result' + return result'' + touchManagedPtr builder + touchManagedPtr oid + freeMem filename' + return maybeResult + ) (do + freeMem filename' + ) + +#if ENABLE_OVERLOADING +data TreeBuilderInsertMethodInfo +instance (signature ~ (T.Text -> Ggit.OId.OId -> Ggit.Enums.FileMode -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderInsertMethodInfo a signature where + overloadedMethod _ = treeBuilderInsert + +#endif + +-- method TreeBuilder::remove +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "builder", argType = TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeBuilder.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path to remove.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_tree_builder_remove" ggit_tree_builder_remove :: + Ptr TreeBuilder -> -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}) + CString -> -- path : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO () + +{- | +Remove an entry from the builder by path. +-} +treeBuilderRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) => + a + {- ^ /@builder@/: a 'GI.Ggit.Objects.TreeBuilder.TreeBuilder'. -} + -> T.Text + {- ^ /@path@/: the path to remove. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +treeBuilderRemove builder path = liftIO $ do + builder' <- unsafeManagedPtrCastPtr builder + path' <- textToCString path + onException (do + propagateGError $ ggit_tree_builder_remove builder' path' + touchManagedPtr builder + freeMem path' + return () + ) (do + freeMem path' + ) + +#if ENABLE_OVERLOADING +data TreeBuilderRemoveMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderRemoveMethodInfo a signature where + overloadedMethod _ = treeBuilderRemove + +#endif + +-- method TreeBuilder::write +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "builder", argType = TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeBuilder.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_tree_builder_write" ggit_tree_builder_write :: + Ptr TreeBuilder -> -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.OId.OId) + +{- | +Write the contents of the tree builder as a tree object. +-} +treeBuilderWrite :: + (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) => + a + {- ^ /@builder@/: a 'GI.Ggit.Objects.TreeBuilder.TreeBuilder'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the 'GI.Ggit.Structs.OId.OId' of the created tree object or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +treeBuilderWrite builder = liftIO $ do + builder' <- unsafeManagedPtrCastPtr builder + onException (do + result <- propagateGError $ ggit_tree_builder_write builder' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr builder + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data TreeBuilderWriteMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderWriteMethodInfo a signature where + overloadedMethod _ = treeBuilderWrite + +#endif + + diff --git a/GI/Ggit/Objects/TreeBuilder.hs-boot b/GI/Ggit/Objects/TreeBuilder.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Objects/TreeBuilder.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Objects.TreeBuilder 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 + +newtype TreeBuilder = TreeBuilder (ManagedPtr TreeBuilder) +instance GObject TreeBuilder where +class (GObject o, O.IsDescendantOf TreeBuilder o) => IsTreeBuilder o +instance (GObject o, O.IsDescendantOf TreeBuilder o) => IsTreeBuilder o +instance O.HasParentTypes TreeBuilder +#if ENABLE_OVERLOADING +data TreeBuilderClearMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeBuilderGetEntryMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeBuilderInsertMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeBuilderRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeBuilderWriteMethodInfo +#endif diff --git a/GI/Ggit/Structs.hs b/GI/Ggit/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs.hs @@ -0,0 +1,105 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs + ( module GI.Ggit.Structs.AnnotatedCommit , + module GI.Ggit.Structs.BlameHunk , + module GI.Ggit.Structs.BlameOptions , + module GI.Ggit.Structs.BranchEnumerator , + module GI.Ggit.Structs.ConfigEntry , + module GI.Ggit.Structs.CredSshInteractivePrompt, + module GI.Ggit.Structs.DiffBinary , + module GI.Ggit.Structs.DiffBinaryFile , + module GI.Ggit.Structs.DiffDelta , + module GI.Ggit.Structs.DiffFile , + module GI.Ggit.Structs.DiffHunk , + module GI.Ggit.Structs.DiffLine , + module GI.Ggit.Structs.DiffSimilarityMetric, + module GI.Ggit.Structs.FetchOptions , + module GI.Ggit.Structs.IndexEntries , + module GI.Ggit.Structs.IndexEntriesResolveUndo, + module GI.Ggit.Structs.IndexEntry , + module GI.Ggit.Structs.IndexEntryResolveUndo, + module GI.Ggit.Structs.MergeOptions , + module GI.Ggit.Structs.Note , + module GI.Ggit.Structs.OId , + module GI.Ggit.Structs.Patch , + module GI.Ggit.Structs.RebaseOperation , + module GI.Ggit.Structs.RebaseOptions , + module GI.Ggit.Structs.RefSpec , + module GI.Ggit.Structs.Reflog , + module GI.Ggit.Structs.ReflogEntry , + module GI.Ggit.Structs.RemoteHead , + module GI.Ggit.Structs.RevertOptions , + module GI.Ggit.Structs.StatusOptions , + module GI.Ggit.Structs.Submodule , + module GI.Ggit.Structs.TransferProgress , + module GI.Ggit.Structs.TreeEntry , + + + ) where + +import GI.Ggit.Structs.AnnotatedCommit +import GI.Ggit.Structs.BlameHunk +import GI.Ggit.Structs.BlameOptions +import GI.Ggit.Structs.BranchEnumerator +import GI.Ggit.Structs.ConfigEntry +import GI.Ggit.Structs.CredSshInteractivePrompt +import GI.Ggit.Structs.DiffBinary +import GI.Ggit.Structs.DiffBinaryFile +import GI.Ggit.Structs.DiffDelta +import GI.Ggit.Structs.DiffFile +import GI.Ggit.Structs.DiffHunk +import GI.Ggit.Structs.DiffLine +import GI.Ggit.Structs.DiffSimilarityMetric +import GI.Ggit.Structs.FetchOptions +import GI.Ggit.Structs.IndexEntries +import GI.Ggit.Structs.IndexEntriesResolveUndo +import GI.Ggit.Structs.IndexEntry +import GI.Ggit.Structs.IndexEntryResolveUndo +import GI.Ggit.Structs.MergeOptions +import GI.Ggit.Structs.Note +import GI.Ggit.Structs.OId +import GI.Ggit.Structs.Patch +import GI.Ggit.Structs.RebaseOperation +import GI.Ggit.Structs.RebaseOptions +import GI.Ggit.Structs.RefSpec +import GI.Ggit.Structs.Reflog +import GI.Ggit.Structs.ReflogEntry +import GI.Ggit.Structs.RemoteHead +import GI.Ggit.Structs.RevertOptions +import GI.Ggit.Structs.StatusOptions +import GI.Ggit.Structs.Submodule +import GI.Ggit.Structs.TransferProgress +import GI.Ggit.Structs.TreeEntry + +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 + + + diff --git a/GI/Ggit/Structs/AnnotatedCommit.hs b/GI/Ggit/Structs/AnnotatedCommit.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/AnnotatedCommit.hs @@ -0,0 +1,217 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents an annotated commit object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.AnnotatedCommit + ( + +-- * Exported types + AnnotatedCommit(..) , + noAnnotatedCommit , + + + -- * Methods +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + AnnotatedCommitGetIdMethodInfo , +#endif + annotatedCommitGetId , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + AnnotatedCommitRefMethodInfo , +#endif + annotatedCommitRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + AnnotatedCommitUnrefMethodInfo , +#endif + annotatedCommitUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype AnnotatedCommit = AnnotatedCommit (ManagedPtr AnnotatedCommit) +foreign import ccall "ggit_annotated_commit_get_type" c_ggit_annotated_commit_get_type :: + IO GType + +instance BoxedObject AnnotatedCommit where + boxedType _ = c_ggit_annotated_commit_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotatedCommit`. +noAnnotatedCommit :: Maybe AnnotatedCommit +noAnnotatedCommit = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotatedCommit +type instance O.AttributeList AnnotatedCommit = AnnotatedCommitAttributeList +type AnnotatedCommitAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method AnnotatedCommit::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "annotated_commit", argType = TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitAnnotatedCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_annotated_commit_get_id" ggit_annotated_commit_get_id :: + Ptr AnnotatedCommit -> -- annotated_commit : TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the commit ID that the given /@annotatedCommit@/ refs to. +-} +annotatedCommitGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + AnnotatedCommit + {- ^ /@annotatedCommit@/: a 'GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the commit ID that the given /@annotatedCommit@/ refs to or 'Nothing'. -} +annotatedCommitGetId annotatedCommit = liftIO $ do + annotatedCommit' <- unsafeManagedPtrGetPtr annotatedCommit + result <- ggit_annotated_commit_get_id annotatedCommit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr annotatedCommit + return maybeResult + +#if ENABLE_OVERLOADING +data AnnotatedCommitGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo AnnotatedCommitGetIdMethodInfo AnnotatedCommit signature where + overloadedMethod _ = annotatedCommitGetId + +#endif + +-- method AnnotatedCommit::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "annotated_commit", argType = TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitAnnotatedCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_annotated_commit_ref" ggit_annotated_commit_ref :: + Ptr AnnotatedCommit -> -- annotated_commit : TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}) + IO (Ptr AnnotatedCommit) + +{- | +Atomically increments the reference count of /@annotatedCommit@/ by one. +This function is MT-safe and may be called from any thread. +-} +annotatedCommitRef :: + (B.CallStack.HasCallStack, MonadIO m) => + AnnotatedCommit + {- ^ /@annotatedCommit@/: a 'GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit'. -} + -> m (Maybe AnnotatedCommit) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit' or 'Nothing'. -} +annotatedCommitRef annotatedCommit = liftIO $ do + annotatedCommit' <- unsafeManagedPtrGetPtr annotatedCommit + result <- ggit_annotated_commit_ref annotatedCommit' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed AnnotatedCommit) result' + return result'' + touchManagedPtr annotatedCommit + return maybeResult + +#if ENABLE_OVERLOADING +data AnnotatedCommitRefMethodInfo +instance (signature ~ (m (Maybe AnnotatedCommit)), MonadIO m) => O.MethodInfo AnnotatedCommitRefMethodInfo AnnotatedCommit signature where + overloadedMethod _ = annotatedCommitRef + +#endif + +-- method AnnotatedCommit::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "annotated_commit", argType = TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitAnnotatedCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_annotated_commit_unref" ggit_annotated_commit_unref :: + Ptr AnnotatedCommit -> -- annotated_commit : TInterface (Name {namespace = "Ggit", name = "AnnotatedCommit"}) + IO () + +{- | +Atomically decrements the reference count of /@annotatedCommit@/ by one. +If the reference count drops to 0, /@annotatedCommit@/ is freed. +-} +annotatedCommitUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + AnnotatedCommit + {- ^ /@annotatedCommit@/: a 'GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit'. -} + -> m () +annotatedCommitUnref annotatedCommit = liftIO $ do + annotatedCommit' <- unsafeManagedPtrGetPtr annotatedCommit + ggit_annotated_commit_unref annotatedCommit' + touchManagedPtr annotatedCommit + return () + +#if ENABLE_OVERLOADING +data AnnotatedCommitUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo AnnotatedCommitUnrefMethodInfo AnnotatedCommit signature where + overloadedMethod _ = annotatedCommitUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveAnnotatedCommitMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotatedCommitMethod "ref" o = AnnotatedCommitRefMethodInfo + ResolveAnnotatedCommitMethod "unref" o = AnnotatedCommitUnrefMethodInfo + ResolveAnnotatedCommitMethod "getId" o = AnnotatedCommitGetIdMethodInfo + ResolveAnnotatedCommitMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotatedCommitMethod t AnnotatedCommit, O.MethodInfo info AnnotatedCommit p) => OL.IsLabel t (AnnotatedCommit -> 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 + + diff --git a/GI/Ggit/Structs/AnnotatedCommit.hs-boot b/GI/Ggit/Structs/AnnotatedCommit.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/AnnotatedCommit.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.AnnotatedCommit 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 + +newtype AnnotatedCommit = AnnotatedCommit (ManagedPtr AnnotatedCommit) +instance BoxedObject AnnotatedCommit where +#if ENABLE_OVERLOADING +data AnnotatedCommitGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotatedCommitRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotatedCommitUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/BlameHunk.hs b/GI/Ggit/Structs/BlameHunk.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/BlameHunk.hs @@ -0,0 +1,581 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a blame hunk. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.BlameHunk + ( + +-- * Exported types + BlameHunk(..) , + noBlameHunk , + + + -- * Methods +-- ** getFinalCommitId #method:getFinalCommitId# + +#if ENABLE_OVERLOADING + BlameHunkGetFinalCommitIdMethodInfo , +#endif + blameHunkGetFinalCommitId , + + +-- ** getFinalSignature #method:getFinalSignature# + +#if ENABLE_OVERLOADING + BlameHunkGetFinalSignatureMethodInfo , +#endif + blameHunkGetFinalSignature , + + +-- ** getFinalStartLineNumber #method:getFinalStartLineNumber# + +#if ENABLE_OVERLOADING + BlameHunkGetFinalStartLineNumberMethodInfo, +#endif + blameHunkGetFinalStartLineNumber , + + +-- ** getLinesInHunk #method:getLinesInHunk# + +#if ENABLE_OVERLOADING + BlameHunkGetLinesInHunkMethodInfo , +#endif + blameHunkGetLinesInHunk , + + +-- ** getOrigCommitId #method:getOrigCommitId# + +#if ENABLE_OVERLOADING + BlameHunkGetOrigCommitIdMethodInfo , +#endif + blameHunkGetOrigCommitId , + + +-- ** getOrigPath #method:getOrigPath# + +#if ENABLE_OVERLOADING + BlameHunkGetOrigPathMethodInfo , +#endif + blameHunkGetOrigPath , + + +-- ** getOrigSignature #method:getOrigSignature# + +#if ENABLE_OVERLOADING + BlameHunkGetOrigSignatureMethodInfo , +#endif + blameHunkGetOrigSignature , + + +-- ** getOrigStartLineNumber #method:getOrigStartLineNumber# + +#if ENABLE_OVERLOADING + BlameHunkGetOrigStartLineNumberMethodInfo, +#endif + blameHunkGetOrigStartLineNumber , + + +-- ** isBoundary #method:isBoundary# + +#if ENABLE_OVERLOADING + BlameHunkIsBoundaryMethodInfo , +#endif + blameHunkIsBoundary , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + BlameHunkRefMethodInfo , +#endif + blameHunkRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + BlameHunkUnrefMethodInfo , +#endif + blameHunkUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype BlameHunk = BlameHunk (ManagedPtr BlameHunk) +foreign import ccall "ggit_blame_hunk_get_type" c_ggit_blame_hunk_get_type :: + IO GType + +instance BoxedObject BlameHunk where + boxedType _ = c_ggit_blame_hunk_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `BlameHunk`. +noBlameHunk :: Maybe BlameHunk +noBlameHunk = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BlameHunk +type instance O.AttributeList BlameHunk = BlameHunkAttributeList +type BlameHunkAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method BlameHunk::get_final_commit_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_final_commit_id" ggit_blame_hunk_get_final_commit_id :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the id of the commit where this hunk was last changed. +-} +blameHunkGetFinalCommitId :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +blameHunkGetFinalCommitId blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_final_commit_id blameHunk' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr blameHunk + return maybeResult + +#if ENABLE_OVERLOADING +data BlameHunkGetFinalCommitIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo BlameHunkGetFinalCommitIdMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetFinalCommitId + +#endif + +-- method BlameHunk::get_final_signature +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_final_signature" ggit_blame_hunk_get_final_signature :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO (Ptr Ggit.Signature.Signature) + +{- | +Get the signature of the final version of the hunk. +-} +blameHunkGetFinalSignature :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m (Maybe Ggit.Signature.Signature) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Signature.Signature' or 'Nothing'. -} +blameHunkGetFinalSignature blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_final_signature blameHunk' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.Signature.Signature) result' + return result'' + touchManagedPtr blameHunk + return maybeResult + +#if ENABLE_OVERLOADING +data BlameHunkGetFinalSignatureMethodInfo +instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m) => O.MethodInfo BlameHunkGetFinalSignatureMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetFinalSignature + +#endif + +-- method BlameHunk::get_final_start_line_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt16) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_final_start_line_number" ggit_blame_hunk_get_final_start_line_number :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO Word16 + +{- | +Get the line number where the hunk begins in the final version of the file. +Line numbers start at 1. +-} +blameHunkGetFinalStartLineNumber :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m Word16 + {- ^ __Returns:__ the final hunk line number. -} +blameHunkGetFinalStartLineNumber blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_final_start_line_number blameHunk' + touchManagedPtr blameHunk + return result + +#if ENABLE_OVERLOADING +data BlameHunkGetFinalStartLineNumberMethodInfo +instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo BlameHunkGetFinalStartLineNumberMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetFinalStartLineNumber + +#endif + +-- method BlameHunk::get_lines_in_hunk +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt16) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_lines_in_hunk" ggit_blame_hunk_get_lines_in_hunk :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO Word16 + +{- | +Get the number of lines in the hunk. +-} +blameHunkGetLinesInHunk :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m Word16 + {- ^ __Returns:__ the number of lines in the hunk. -} +blameHunkGetLinesInHunk blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_lines_in_hunk blameHunk' + touchManagedPtr blameHunk + return result + +#if ENABLE_OVERLOADING +data BlameHunkGetLinesInHunkMethodInfo +instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo BlameHunkGetLinesInHunkMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetLinesInHunk + +#endif + +-- method BlameHunk::get_orig_commit_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_orig_commit_id" ggit_blame_hunk_get_orig_commit_id :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the id of the commit where the hunk was found. This is usually the same +the final commit id, except when @/GGIT_BLAME_TRACK_COPIES_ANY_COMMIT/@ was used. +-} +blameHunkGetOrigCommitId :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +blameHunkGetOrigCommitId blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_orig_commit_id blameHunk' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr blameHunk + return maybeResult + +#if ENABLE_OVERLOADING +data BlameHunkGetOrigCommitIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo BlameHunkGetOrigCommitIdMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetOrigCommitId + +#endif + +-- method BlameHunk::get_orig_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_orig_path" ggit_blame_hunk_get_orig_path :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO CString + +{- | +Get the path of the file where this hunk originated, as of the commit +specified by @/ggit_blame_hunk_get_orig_commit_id/@. +-} +blameHunkGetOrigPath :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the path or 'Nothing'. -} +blameHunkGetOrigPath blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_orig_path blameHunk' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr blameHunk + return maybeResult + +#if ENABLE_OVERLOADING +data BlameHunkGetOrigPathMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo BlameHunkGetOrigPathMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetOrigPath + +#endif + +-- method BlameHunk::get_orig_signature +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_orig_signature" ggit_blame_hunk_get_orig_signature :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO (Ptr Ggit.Signature.Signature) + +{- | +Get the signature of the commit specified by @/ggit_blame_hunk_get_orig_commit_id/@. +-} +blameHunkGetOrigSignature :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m (Maybe Ggit.Signature.Signature) + {- ^ __Returns:__ a 'GI.Ggit.Objects.Signature.Signature' or 'Nothing'. -} +blameHunkGetOrigSignature blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_orig_signature blameHunk' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.Signature.Signature) result' + return result'' + touchManagedPtr blameHunk + return maybeResult + +#if ENABLE_OVERLOADING +data BlameHunkGetOrigSignatureMethodInfo +instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m) => O.MethodInfo BlameHunkGetOrigSignatureMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetOrigSignature + +#endif + +-- method BlameHunk::get_orig_start_line_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt16) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_get_orig_start_line_number" ggit_blame_hunk_get_orig_start_line_number :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO Word16 + +{- | +Get the line number where the hunk begins in the file specified by +@/ggit_blame_hunk_get_orig_path/@ at the commit specified by +@/ggit_blame_hunk_get_orig_commit_id/@. Line numbers start at 1. +-} +blameHunkGetOrigStartLineNumber :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m Word16 + {- ^ __Returns:__ the orig hunk line number. -} +blameHunkGetOrigStartLineNumber blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_get_orig_start_line_number blameHunk' + touchManagedPtr blameHunk + return result + +#if ENABLE_OVERLOADING +data BlameHunkGetOrigStartLineNumberMethodInfo +instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo BlameHunkGetOrigStartLineNumberMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkGetOrigStartLineNumber + +#endif + +-- method BlameHunk::is_boundary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_is_boundary" ggit_blame_hunk_is_boundary :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO CInt + +{- | +Get whether the hunk has been tracked to a boundary commit (the root, +or the commit specified in @/ggit_blame_options_set_oldest_commit/@). +-} +blameHunkIsBoundary :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m Bool + {- ^ __Returns:__ whether the hunk is at a boundary commit. -} +blameHunkIsBoundary blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_is_boundary blameHunk' + let result' = (/= 0) result + touchManagedPtr blameHunk + return result' + +#if ENABLE_OVERLOADING +data BlameHunkIsBoundaryMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo BlameHunkIsBoundaryMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkIsBoundary + +#endif + +-- method BlameHunk::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlameHunk"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_ref" ggit_blame_hunk_ref :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO (Ptr BlameHunk) + +{- | +Atomically increments the reference count of /@blameHunk@/ by one. +This function is MT-safe and may be called from any thread. +-} +blameHunkRef :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m (Maybe BlameHunk) + {- ^ __Returns:__ a 'GI.Ggit.Structs.BlameHunk.BlameHunk' or 'Nothing'. -} +blameHunkRef blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + result <- ggit_blame_hunk_ref blameHunk' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed BlameHunk) result' + return result'' + touchManagedPtr blameHunk + return maybeResult + +#if ENABLE_OVERLOADING +data BlameHunkRefMethodInfo +instance (signature ~ (m (Maybe BlameHunk)), MonadIO m) => O.MethodInfo BlameHunkRefMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkRef + +#endif + +-- method BlameHunk::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_hunk", argType = TInterface (Name {namespace = "Ggit", name = "BlameHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_hunk_unref" ggit_blame_hunk_unref :: + Ptr BlameHunk -> -- blame_hunk : TInterface (Name {namespace = "Ggit", name = "BlameHunk"}) + IO () + +{- | +Atomically decrements the reference count of /@blameHunk@/ by one. +If the reference count drops to 0, /@blameHunk@/ is freed. +-} +blameHunkUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameHunk + {- ^ /@blameHunk@/: a 'GI.Ggit.Structs.BlameHunk.BlameHunk'. -} + -> m () +blameHunkUnref blameHunk = liftIO $ do + blameHunk' <- unsafeManagedPtrGetPtr blameHunk + ggit_blame_hunk_unref blameHunk' + touchManagedPtr blameHunk + return () + +#if ENABLE_OVERLOADING +data BlameHunkUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BlameHunkUnrefMethodInfo BlameHunk signature where + overloadedMethod _ = blameHunkUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveBlameHunkMethod (t :: Symbol) (o :: *) :: * where + ResolveBlameHunkMethod "isBoundary" o = BlameHunkIsBoundaryMethodInfo + ResolveBlameHunkMethod "ref" o = BlameHunkRefMethodInfo + ResolveBlameHunkMethod "unref" o = BlameHunkUnrefMethodInfo + ResolveBlameHunkMethod "getFinalCommitId" o = BlameHunkGetFinalCommitIdMethodInfo + ResolveBlameHunkMethod "getFinalSignature" o = BlameHunkGetFinalSignatureMethodInfo + ResolveBlameHunkMethod "getFinalStartLineNumber" o = BlameHunkGetFinalStartLineNumberMethodInfo + ResolveBlameHunkMethod "getLinesInHunk" o = BlameHunkGetLinesInHunkMethodInfo + ResolveBlameHunkMethod "getOrigCommitId" o = BlameHunkGetOrigCommitIdMethodInfo + ResolveBlameHunkMethod "getOrigPath" o = BlameHunkGetOrigPathMethodInfo + ResolveBlameHunkMethod "getOrigSignature" o = BlameHunkGetOrigSignatureMethodInfo + ResolveBlameHunkMethod "getOrigStartLineNumber" o = BlameHunkGetOrigStartLineNumberMethodInfo + ResolveBlameHunkMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBlameHunkMethod t BlameHunk, O.MethodInfo info BlameHunk p) => OL.IsLabel t (BlameHunk -> 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 + + diff --git a/GI/Ggit/Structs/BlameHunk.hs-boot b/GI/Ggit/Structs/BlameHunk.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/BlameHunk.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.BlameHunk 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 + +newtype BlameHunk = BlameHunk (ManagedPtr BlameHunk) +instance BoxedObject BlameHunk where +#if ENABLE_OVERLOADING +data BlameHunkGetFinalCommitIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkGetFinalSignatureMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkGetFinalStartLineNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkGetLinesInHunkMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkGetOrigCommitIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkGetOrigPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkGetOrigSignatureMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkGetOrigStartLineNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkIsBoundaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameHunkUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/BlameOptions.hs b/GI/Ggit/Structs/BlameOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/BlameOptions.hs @@ -0,0 +1,670 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents blame options. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.BlameOptions + ( + +-- * Exported types + BlameOptions(..) , + noBlameOptions , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + BlameOptionsCopyMethodInfo , +#endif + blameOptionsCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + BlameOptionsFreeMethodInfo , +#endif + blameOptionsFree , + + +-- ** getMaximumLine #method:getMaximumLine# + +#if ENABLE_OVERLOADING + BlameOptionsGetMaximumLineMethodInfo , +#endif + blameOptionsGetMaximumLine , + + +-- ** getMinimumLine #method:getMinimumLine# + +#if ENABLE_OVERLOADING + BlameOptionsGetMinimumLineMethodInfo , +#endif + blameOptionsGetMinimumLine , + + +-- ** getMinimumMatchCharacters #method:getMinimumMatchCharacters# + +#if ENABLE_OVERLOADING + BlameOptionsGetMinimumMatchCharactersMethodInfo, +#endif + blameOptionsGetMinimumMatchCharacters , + + +-- ** getNewestCommit #method:getNewestCommit# + +#if ENABLE_OVERLOADING + BlameOptionsGetNewestCommitMethodInfo , +#endif + blameOptionsGetNewestCommit , + + +-- ** getOldestCommit #method:getOldestCommit# + +#if ENABLE_OVERLOADING + BlameOptionsGetOldestCommitMethodInfo , +#endif + blameOptionsGetOldestCommit , + + +-- ** new #method:new# + + blameOptionsNew , + + +-- ** setMaximumLine #method:setMaximumLine# + +#if ENABLE_OVERLOADING + BlameOptionsSetMaximumLineMethodInfo , +#endif + blameOptionsSetMaximumLine , + + +-- ** setMinimumLine #method:setMinimumLine# + +#if ENABLE_OVERLOADING + BlameOptionsSetMinimumLineMethodInfo , +#endif + blameOptionsSetMinimumLine , + + +-- ** setMinimumMatchCharacters #method:setMinimumMatchCharacters# + +#if ENABLE_OVERLOADING + BlameOptionsSetMinimumMatchCharactersMethodInfo, +#endif + blameOptionsSetMinimumMatchCharacters , + + +-- ** setNewestCommit #method:setNewestCommit# + +#if ENABLE_OVERLOADING + BlameOptionsSetNewestCommitMethodInfo , +#endif + blameOptionsSetNewestCommit , + + +-- ** setOldestCommit #method:setOldestCommit# + +#if ENABLE_OVERLOADING + BlameOptionsSetOldestCommitMethodInfo , +#endif + blameOptionsSetOldestCommit , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype BlameOptions = BlameOptions (ManagedPtr BlameOptions) +foreign import ccall "ggit_blame_options_get_type" c_ggit_blame_options_get_type :: + IO GType + +instance BoxedObject BlameOptions where + boxedType _ = c_ggit_blame_options_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `BlameOptions`. +noBlameOptions :: Maybe BlameOptions +noBlameOptions = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BlameOptions +type instance O.AttributeList BlameOptions = BlameOptionsAttributeList +type BlameOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method BlameOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlameOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_new" ggit_blame_options_new :: + IO (Ptr BlameOptions) + +{- | +Create a new, empty 'GI.Ggit.Structs.BlameOptions.BlameOptions'. +-} +blameOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m BlameOptions + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} +blameOptionsNew = liftIO $ do + result <- ggit_blame_options_new + checkUnexpectedReturnNULL "blameOptionsNew" result + result' <- (wrapBoxed BlameOptions) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method BlameOptions::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BlameOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_copy" ggit_blame_options_copy :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO (Ptr BlameOptions) + +{- | +Copies /@blameOptions@/ into a newly allocated 'GI.Ggit.Structs.BlameOptions.BlameOptions'. +-} +blameOptionsCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m (Maybe BlameOptions) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.BlameOptions.BlameOptions' or 'Nothing'. -} +blameOptionsCopy blameOptions = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + result <- ggit_blame_options_copy blameOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed BlameOptions) result' + return result'' + touchManagedPtr blameOptions + return maybeResult + +#if ENABLE_OVERLOADING +data BlameOptionsCopyMethodInfo +instance (signature ~ (m (Maybe BlameOptions)), MonadIO m) => O.MethodInfo BlameOptionsCopyMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsCopy + +#endif + +-- method BlameOptions::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_free" ggit_blame_options_free :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO () + +{- | +Frees /@blameOptions@/. +-} +blameOptionsFree :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m () +blameOptionsFree blameOptions = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + ggit_blame_options_free blameOptions' + touchManagedPtr blameOptions + return () + +#if ENABLE_OVERLOADING +data BlameOptionsFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BlameOptionsFreeMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsFree + +#endif + +-- method BlameOptions::get_maximum_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_get_maximum_line" ggit_blame_options_get_maximum_line :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO Word32 + +{- | +Get the last line in the file to consider. The default is 1. +-} +blameOptionsGetMaximumLine :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m Word32 + {- ^ __Returns:__ the last line to consider. -} +blameOptionsGetMaximumLine blameOptions = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + result <- ggit_blame_options_get_maximum_line blameOptions' + touchManagedPtr blameOptions + return result + +#if ENABLE_OVERLOADING +data BlameOptionsGetMaximumLineMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BlameOptionsGetMaximumLineMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsGetMaximumLine + +#endif + +-- method BlameOptions::get_minimum_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_get_minimum_line" ggit_blame_options_get_minimum_line :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO Word32 + +{- | +Get the first line in the file to consider. The default is 1. +-} +blameOptionsGetMinimumLine :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m Word32 + {- ^ __Returns:__ the first line to consider. -} +blameOptionsGetMinimumLine blameOptions = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + result <- ggit_blame_options_get_minimum_line blameOptions' + touchManagedPtr blameOptions + return result + +#if ENABLE_OVERLOADING +data BlameOptionsGetMinimumLineMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BlameOptionsGetMinimumLineMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsGetMinimumLine + +#endif + +-- method BlameOptions::get_minimum_match_characters +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt16) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_get_minimum_match_characters" ggit_blame_options_get_minimum_match_characters :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO Word16 + +{- | +Get the minimum number of characters that must be detected as moving\/copying +within a file for it to associate those lines with a parent commit. This is +only used when any of the @/GGIT_BLAME_TRACK_COPIES_SAME_FILE/@ flag is +specified. The default value is 20. +-} +blameOptionsGetMinimumMatchCharacters :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m Word16 + {- ^ __Returns:__ the minimum number of characters. -} +blameOptionsGetMinimumMatchCharacters blameOptions = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + result <- ggit_blame_options_get_minimum_match_characters blameOptions' + touchManagedPtr blameOptions + return result + +#if ENABLE_OVERLOADING +data BlameOptionsGetMinimumMatchCharactersMethodInfo +instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo BlameOptionsGetMinimumMatchCharactersMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsGetMinimumMatchCharacters + +#endif + +-- method BlameOptions::get_newest_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_get_newest_commit" ggit_blame_options_get_newest_commit :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the id of the newest commit to consider in the blame. The default +value of 'Nothing' indicates to use HEAD. +-} +blameOptionsGetNewestCommit :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +blameOptionsGetNewestCommit blameOptions = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + result <- ggit_blame_options_get_newest_commit blameOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr blameOptions + return maybeResult + +#if ENABLE_OVERLOADING +data BlameOptionsGetNewestCommitMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo BlameOptionsGetNewestCommitMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsGetNewestCommit + +#endif + +-- method BlameOptions::get_oldest_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_get_oldest_commit" ggit_blame_options_get_oldest_commit :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the id of the oldest commit to consider in the blame. Teh default value +of 'Nothing' indicates to used HEAD. +-} +blameOptionsGetOldestCommit :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +blameOptionsGetOldestCommit blameOptions = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + result <- ggit_blame_options_get_oldest_commit blameOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr blameOptions + return maybeResult + +#if ENABLE_OVERLOADING +data BlameOptionsGetOldestCommitMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo BlameOptionsGetOldestCommitMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsGetOldestCommit + +#endif + +-- method BlameOptions::set_maximum_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the last line to consider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_set_maximum_line" ggit_blame_options_set_maximum_line :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + Word32 -> -- line : TBasicType TUInt32 + IO () + +{- | +Set the last line in the file to consider. Lines start at 1. +-} +blameOptionsSetMaximumLine :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> Word32 + {- ^ /@line@/: the last line to consider. -} + -> m () +blameOptionsSetMaximumLine blameOptions line = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + ggit_blame_options_set_maximum_line blameOptions' line + touchManagedPtr blameOptions + return () + +#if ENABLE_OVERLOADING +data BlameOptionsSetMaximumLineMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetMaximumLineMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsSetMaximumLine + +#endif + +-- method BlameOptions::set_minimum_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the first line to consider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_set_minimum_line" ggit_blame_options_set_minimum_line :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + Word32 -> -- line : TBasicType TUInt32 + IO () + +{- | +Set the first line in the file to consider. Lines start at 1. +-} +blameOptionsSetMinimumLine :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> Word32 + {- ^ /@line@/: the first line to consider. -} + -> m () +blameOptionsSetMinimumLine blameOptions line = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + ggit_blame_options_set_minimum_line blameOptions' line + touchManagedPtr blameOptions + return () + +#if ENABLE_OVERLOADING +data BlameOptionsSetMinimumLineMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetMinimumLineMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsSetMinimumLine + +#endif + +-- method BlameOptions::set_minimum_match_characters +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "characters", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum number of characters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_set_minimum_match_characters" ggit_blame_options_set_minimum_match_characters :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + Word16 -> -- characters : TBasicType TUInt16 + IO () + +{- | +Set the minimum number of characters that must be detected as moving\/copying +within a file for it to associate those lines with a parent commit. This is +only used when any of the @/GGIT_BLAME_TRACK_COPIES_/@ flags are specified. The +default value is 20. +-} +blameOptionsSetMinimumMatchCharacters :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> Word16 + {- ^ /@characters@/: the minimum number of characters. -} + -> m () +blameOptionsSetMinimumMatchCharacters blameOptions characters = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + ggit_blame_options_set_minimum_match_characters blameOptions' characters + touchManagedPtr blameOptions + return () + +#if ENABLE_OVERLOADING +data BlameOptionsSetMinimumMatchCharactersMethodInfo +instance (signature ~ (Word16 -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetMinimumMatchCharactersMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsSetMinimumMatchCharacters + +#endif + +-- method BlameOptions::set_newest_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitOId or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_set_newest_commit" ggit_blame_options_set_newest_commit :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO () + +{- | +Set the id of the newest commit to consider in the blame. Specify 'Nothing' to +set the default value which indicates to use HEAD. +-} +blameOptionsSetNewestCommit :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> Maybe (Ggit.OId.OId) + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} + -> m () +blameOptionsSetNewestCommit blameOptions oid = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + maybeOid <- case oid of + Nothing -> return nullPtr + Just jOid -> do + jOid' <- unsafeManagedPtrGetPtr jOid + return jOid' + ggit_blame_options_set_newest_commit blameOptions' maybeOid + touchManagedPtr blameOptions + whenJust oid touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data BlameOptionsSetNewestCommitMethodInfo +instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetNewestCommitMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsSetNewestCommit + +#endif + +-- method BlameOptions::set_oldest_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "blame_options", argType = TInterface (Name {namespace = "Ggit", name = "BlameOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBlameOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_blame_options_set_oldest_commit" ggit_blame_options_set_oldest_commit :: + Ptr BlameOptions -> -- blame_options : TInterface (Name {namespace = "Ggit", name = "BlameOptions"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO () + +{- | +Set the id of the oldest commit to consider in the blame. Specify 'Nothing' to +set the default value which indicates to consider the first commit without +a parent. +-} +blameOptionsSetOldestCommit :: + (B.CallStack.HasCallStack, MonadIO m) => + BlameOptions + {- ^ /@blameOptions@/: a 'GI.Ggit.Structs.BlameOptions.BlameOptions'. -} + -> Maybe (Ggit.OId.OId) + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m () +blameOptionsSetOldestCommit blameOptions oid = liftIO $ do + blameOptions' <- unsafeManagedPtrGetPtr blameOptions + maybeOid <- case oid of + Nothing -> return nullPtr + Just jOid -> do + jOid' <- unsafeManagedPtrGetPtr jOid + return jOid' + ggit_blame_options_set_oldest_commit blameOptions' maybeOid + touchManagedPtr blameOptions + whenJust oid touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data BlameOptionsSetOldestCommitMethodInfo +instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m) => O.MethodInfo BlameOptionsSetOldestCommitMethodInfo BlameOptions signature where + overloadedMethod _ = blameOptionsSetOldestCommit + +#endif + +#if ENABLE_OVERLOADING +type family ResolveBlameOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveBlameOptionsMethod "copy" o = BlameOptionsCopyMethodInfo + ResolveBlameOptionsMethod "free" o = BlameOptionsFreeMethodInfo + ResolveBlameOptionsMethod "getMaximumLine" o = BlameOptionsGetMaximumLineMethodInfo + ResolveBlameOptionsMethod "getMinimumLine" o = BlameOptionsGetMinimumLineMethodInfo + ResolveBlameOptionsMethod "getMinimumMatchCharacters" o = BlameOptionsGetMinimumMatchCharactersMethodInfo + ResolveBlameOptionsMethod "getNewestCommit" o = BlameOptionsGetNewestCommitMethodInfo + ResolveBlameOptionsMethod "getOldestCommit" o = BlameOptionsGetOldestCommitMethodInfo + ResolveBlameOptionsMethod "setMaximumLine" o = BlameOptionsSetMaximumLineMethodInfo + ResolveBlameOptionsMethod "setMinimumLine" o = BlameOptionsSetMinimumLineMethodInfo + ResolveBlameOptionsMethod "setMinimumMatchCharacters" o = BlameOptionsSetMinimumMatchCharactersMethodInfo + ResolveBlameOptionsMethod "setNewestCommit" o = BlameOptionsSetNewestCommitMethodInfo + ResolveBlameOptionsMethod "setOldestCommit" o = BlameOptionsSetOldestCommitMethodInfo + ResolveBlameOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBlameOptionsMethod t BlameOptions, O.MethodInfo info BlameOptions p) => OL.IsLabel t (BlameOptions -> 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 + + diff --git a/GI/Ggit/Structs/BlameOptions.hs-boot b/GI/Ggit/Structs/BlameOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/BlameOptions.hs-boot @@ -0,0 +1,62 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.BlameOptions 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 + +newtype BlameOptions = BlameOptions (ManagedPtr BlameOptions) +instance BoxedObject BlameOptions where +#if ENABLE_OVERLOADING +data BlameOptionsCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsGetMaximumLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsGetMinimumLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsGetMinimumMatchCharactersMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsGetNewestCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsGetOldestCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsSetMaximumLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsSetMinimumLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsSetMinimumMatchCharactersMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsSetNewestCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data BlameOptionsSetOldestCommitMethodInfo +#endif diff --git a/GI/Ggit/Structs/BranchEnumerator.hs b/GI/Ggit/Structs/BranchEnumerator.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/BranchEnumerator.hs @@ -0,0 +1,307 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a branch enumerator. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.BranchEnumerator + ( + +-- * Exported types + BranchEnumerator(..) , + noBranchEnumerator , + + + -- * Methods +-- ** get #method:get# + +#if ENABLE_OVERLOADING + BranchEnumeratorGetMethodInfo , +#endif + branchEnumeratorGet , + + +-- ** iterator #method:iterator# + +#if ENABLE_OVERLOADING + BranchEnumeratorIteratorMethodInfo , +#endif + branchEnumeratorIterator , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + BranchEnumeratorNextMethodInfo , +#endif + branchEnumeratorNext , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + BranchEnumeratorRefMethodInfo , +#endif + branchEnumeratorRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + BranchEnumeratorUnrefMethodInfo , +#endif + branchEnumeratorUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.Ref as Ggit.Ref + +-- | Memory-managed wrapper type. +newtype BranchEnumerator = BranchEnumerator (ManagedPtr BranchEnumerator) +foreign import ccall "ggit_branch_enumerator_get_type" c_ggit_branch_enumerator_get_type :: + IO GType + +instance BoxedObject BranchEnumerator where + boxedType _ = c_ggit_branch_enumerator_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `BranchEnumerator`. +noBranchEnumerator :: Maybe BranchEnumerator +noBranchEnumerator = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BranchEnumerator +type instance O.AttributeList BranchEnumerator = BranchEnumeratorAttributeList +type BranchEnumeratorAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method BranchEnumerator::get +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranchEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Ref"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_branch_enumerator_get" ggit_branch_enumerator_get :: + Ptr BranchEnumerator -> -- enumerator : TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}) + IO (Ptr Ggit.Ref.Ref) + +{- | +Returns the currently being enumerated branch, or 'Nothing'. Note that the +returned GgitRef will be of type GgitBranch if the ref represents a local +branch. +-} +branchEnumeratorGet :: + (B.CallStack.HasCallStack, MonadIO m) => + BranchEnumerator + {- ^ /@enumerator@/: a 'GI.Ggit.Structs.BranchEnumerator.BranchEnumerator'. -} + -> m (Maybe Ggit.Ref.Ref) + {- ^ __Returns:__ the branch ref or 'Nothing'. -} +branchEnumeratorGet enumerator = liftIO $ do + enumerator' <- unsafeManagedPtrGetPtr enumerator + result <- ggit_branch_enumerator_get enumerator' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Ref.Ref) result' + return result'' + touchManagedPtr enumerator + return maybeResult + +#if ENABLE_OVERLOADING +data BranchEnumeratorGetMethodInfo +instance (signature ~ (m (Maybe Ggit.Ref.Ref)), MonadIO m) => O.MethodInfo BranchEnumeratorGetMethodInfo BranchEnumerator signature where + overloadedMethod _ = branchEnumeratorGet + +#endif + +-- method BranchEnumerator::iterator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranchEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_branch_enumerator_iterator" ggit_branch_enumerator_iterator :: + Ptr BranchEnumerator -> -- enumerator : TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}) + IO (Ptr BranchEnumerator) + +{- | +Get an iterator for the enumerator. +-} +branchEnumeratorIterator :: + (B.CallStack.HasCallStack, MonadIO m) => + BranchEnumerator + {- ^ /@enumerator@/: a 'GI.Ggit.Structs.BranchEnumerator.BranchEnumerator'. -} + -> m (Maybe BranchEnumerator) + {- ^ __Returns:__ a 'GI.Ggit.Structs.BranchEnumerator.BranchEnumerator' or 'Nothing'. -} +branchEnumeratorIterator enumerator = liftIO $ do + enumerator' <- unsafeManagedPtrGetPtr enumerator + result <- ggit_branch_enumerator_iterator enumerator' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed BranchEnumerator) result' + return result'' + touchManagedPtr enumerator + return maybeResult + +#if ENABLE_OVERLOADING +data BranchEnumeratorIteratorMethodInfo +instance (signature ~ (m (Maybe BranchEnumerator)), MonadIO m) => O.MethodInfo BranchEnumeratorIteratorMethodInfo BranchEnumerator signature where + overloadedMethod _ = branchEnumeratorIterator + +#endif + +-- method BranchEnumerator::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranchEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_branch_enumerator_next" ggit_branch_enumerator_next :: + Ptr BranchEnumerator -> -- enumerator : TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}) + IO CInt + +{- | +Move the enumerator to the next branch. +-} +branchEnumeratorNext :: + (B.CallStack.HasCallStack, MonadIO m) => + BranchEnumerator + {- ^ /@enumerator@/: a 'GI.Ggit.Structs.BranchEnumerator.BranchEnumerator'. -} + -> m Bool + {- ^ __Returns:__ 'True' if there is a next branch, 'False' otherwise. -} +branchEnumeratorNext enumerator = liftIO $ do + enumerator' <- unsafeManagedPtrGetPtr enumerator + result <- ggit_branch_enumerator_next enumerator' + let result' = (/= 0) result + touchManagedPtr enumerator + return result' + +#if ENABLE_OVERLOADING +data BranchEnumeratorNextMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo BranchEnumeratorNextMethodInfo BranchEnumerator signature where + overloadedMethod _ = branchEnumeratorNext + +#endif + +-- method BranchEnumerator::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranchEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_branch_enumerator_ref" ggit_branch_enumerator_ref :: + Ptr BranchEnumerator -> -- enumerator : TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}) + IO (Ptr BranchEnumerator) + +{- | +/No description available in the introspection data./ +-} +branchEnumeratorRef :: + (B.CallStack.HasCallStack, MonadIO m) => + BranchEnumerator + {- ^ /@enumerator@/: a 'GI.Ggit.Structs.BranchEnumerator.BranchEnumerator'. -} + -> m (Maybe BranchEnumerator) + {- ^ __Returns:__ /@enumerator@/ or 'Nothing' -} +branchEnumeratorRef enumerator = liftIO $ do + enumerator' <- unsafeManagedPtrGetPtr enumerator + result <- ggit_branch_enumerator_ref enumerator' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed BranchEnumerator) result' + return result'' + touchManagedPtr enumerator + return maybeResult + +#if ENABLE_OVERLOADING +data BranchEnumeratorRefMethodInfo +instance (signature ~ (m (Maybe BranchEnumerator)), MonadIO m) => O.MethodInfo BranchEnumeratorRefMethodInfo BranchEnumerator signature where + overloadedMethod _ = branchEnumeratorRef + +#endif + +-- method BranchEnumerator::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enumerator", argType = TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitBranchEnumerator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_branch_enumerator_unref" ggit_branch_enumerator_unref :: + Ptr BranchEnumerator -> -- enumerator : TInterface (Name {namespace = "Ggit", name = "BranchEnumerator"}) + IO () + +{- | +/No description available in the introspection data./ +-} +branchEnumeratorUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + BranchEnumerator + {- ^ /@enumerator@/: a 'GI.Ggit.Structs.BranchEnumerator.BranchEnumerator'. -} + -> m () +branchEnumeratorUnref enumerator = liftIO $ do + enumerator' <- unsafeManagedPtrGetPtr enumerator + ggit_branch_enumerator_unref enumerator' + touchManagedPtr enumerator + return () + +#if ENABLE_OVERLOADING +data BranchEnumeratorUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BranchEnumeratorUnrefMethodInfo BranchEnumerator signature where + overloadedMethod _ = branchEnumeratorUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveBranchEnumeratorMethod (t :: Symbol) (o :: *) :: * where + ResolveBranchEnumeratorMethod "get" o = BranchEnumeratorGetMethodInfo + ResolveBranchEnumeratorMethod "iterator" o = BranchEnumeratorIteratorMethodInfo + ResolveBranchEnumeratorMethod "next" o = BranchEnumeratorNextMethodInfo + ResolveBranchEnumeratorMethod "ref" o = BranchEnumeratorRefMethodInfo + ResolveBranchEnumeratorMethod "unref" o = BranchEnumeratorUnrefMethodInfo + ResolveBranchEnumeratorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBranchEnumeratorMethod t BranchEnumerator, O.MethodInfo info BranchEnumerator p) => OL.IsLabel t (BranchEnumerator -> 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 + + diff --git a/GI/Ggit/Structs/BranchEnumerator.hs-boot b/GI/Ggit/Structs/BranchEnumerator.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/BranchEnumerator.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.BranchEnumerator 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 + +newtype BranchEnumerator = BranchEnumerator (ManagedPtr BranchEnumerator) +instance BoxedObject BranchEnumerator where +#if ENABLE_OVERLOADING +data BranchEnumeratorGetMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchEnumeratorIteratorMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchEnumeratorNextMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchEnumeratorRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data BranchEnumeratorUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/ConfigEntry.hs b/GI/Ggit/Structs/ConfigEntry.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/ConfigEntry.hs @@ -0,0 +1,307 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git configuration entry. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.ConfigEntry + ( + +-- * Exported types + ConfigEntry(..) , + noConfigEntry , + + + -- * Methods +-- ** getLevel #method:getLevel# + +#if ENABLE_OVERLOADING + ConfigEntryGetLevelMethodInfo , +#endif + configEntryGetLevel , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + ConfigEntryGetNameMethodInfo , +#endif + configEntryGetName , + + +-- ** getValue #method:getValue# + +#if ENABLE_OVERLOADING + ConfigEntryGetValueMethodInfo , +#endif + configEntryGetValue , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + ConfigEntryRefMethodInfo , +#endif + configEntryRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + ConfigEntryUnrefMethodInfo , +#endif + configEntryUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums + +-- | Memory-managed wrapper type. +newtype ConfigEntry = ConfigEntry (ManagedPtr ConfigEntry) +foreign import ccall "ggit_config_entry_get_type" c_ggit_config_entry_get_type :: + IO GType + +instance BoxedObject ConfigEntry where + boxedType _ = c_ggit_config_entry_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `ConfigEntry`. +noConfigEntry :: Maybe ConfigEntry +noConfigEntry = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ConfigEntry +type instance O.AttributeList ConfigEntry = ConfigEntryAttributeList +type ConfigEntryAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method ConfigEntry::get_level +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "ConfigLevel"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_entry_get_level" ggit_config_entry_get_level :: + Ptr ConfigEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}) + IO CInt + +{- | +Gets the 'GI.Ggit.Enums.ConfigLevel' of /@entry@/. +-} +configEntryGetLevel :: + (B.CallStack.HasCallStack, MonadIO m) => + ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> m Ggit.Enums.ConfigLevel + {- ^ __Returns:__ the 'GI.Ggit.Enums.ConfigLevel' of /@entry@/. -} +configEntryGetLevel entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_config_entry_get_level entry' + let result' = (toEnum . fromIntegral) result + touchManagedPtr entry + return result' + +#if ENABLE_OVERLOADING +data ConfigEntryGetLevelMethodInfo +instance (signature ~ (m Ggit.Enums.ConfigLevel), MonadIO m) => O.MethodInfo ConfigEntryGetLevelMethodInfo ConfigEntry signature where + overloadedMethod _ = configEntryGetLevel + +#endif + +-- method ConfigEntry::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_entry_get_name" ggit_config_entry_get_name :: + Ptr ConfigEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}) + IO CString + +{- | +Gets the name of /@entry@/. +-} +configEntryGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of /@entry@/ or 'Nothing'. -} +configEntryGetName entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_config_entry_get_name entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data ConfigEntryGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo ConfigEntryGetNameMethodInfo ConfigEntry signature where + overloadedMethod _ = configEntryGetName + +#endif + +-- method ConfigEntry::get_value +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_entry_get_value" ggit_config_entry_get_value :: + Ptr ConfigEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}) + IO CString + +{- | +Gets the value of /@entry@/. +-} +configEntryGetValue :: + (B.CallStack.HasCallStack, MonadIO m) => + ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the value of /@entry@/ or 'Nothing'. -} +configEntryGetValue entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_config_entry_get_value entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data ConfigEntryGetValueMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo ConfigEntryGetValueMethodInfo ConfigEntry signature where + overloadedMethod _ = configEntryGetValue + +#endif + +-- method ConfigEntry::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "ConfigEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_entry_ref" ggit_config_entry_ref :: + Ptr ConfigEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}) + IO (Ptr ConfigEntry) + +{- | +Atomically increments the reference count of /@entry@/ by one. +This function is MT-safe and may be called from any thread. +-} +configEntryRef :: + (B.CallStack.HasCallStack, MonadIO m) => + ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> m (Maybe ConfigEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry' or 'Nothing'. -} +configEntryRef entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_config_entry_ref entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed ConfigEntry) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data ConfigEntryRefMethodInfo +instance (signature ~ (m (Maybe ConfigEntry)), MonadIO m) => O.MethodInfo ConfigEntryRefMethodInfo ConfigEntry signature where + overloadedMethod _ = configEntryRef + +#endif + +-- method ConfigEntry::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitConfigEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_config_entry_unref" ggit_config_entry_unref :: + Ptr ConfigEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"}) + IO () + +{- | +Atomically decrements the reference count of /@entry@/ by one. +If the reference count drops to 0, /@entry@/ is freed. +-} +configEntryUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + ConfigEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'. -} + -> m () +configEntryUnref entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_config_entry_unref entry' + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data ConfigEntryUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ConfigEntryUnrefMethodInfo ConfigEntry signature where + overloadedMethod _ = configEntryUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveConfigEntryMethod (t :: Symbol) (o :: *) :: * where + ResolveConfigEntryMethod "ref" o = ConfigEntryRefMethodInfo + ResolveConfigEntryMethod "unref" o = ConfigEntryUnrefMethodInfo + ResolveConfigEntryMethod "getLevel" o = ConfigEntryGetLevelMethodInfo + ResolveConfigEntryMethod "getName" o = ConfigEntryGetNameMethodInfo + ResolveConfigEntryMethod "getValue" o = ConfigEntryGetValueMethodInfo + ResolveConfigEntryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveConfigEntryMethod t ConfigEntry, O.MethodInfo info ConfigEntry p) => OL.IsLabel t (ConfigEntry -> 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 + + diff --git a/GI/Ggit/Structs/ConfigEntry.hs-boot b/GI/Ggit/Structs/ConfigEntry.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/ConfigEntry.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.ConfigEntry 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 + +newtype ConfigEntry = ConfigEntry (ManagedPtr ConfigEntry) +instance BoxedObject ConfigEntry where +#if ENABLE_OVERLOADING +data ConfigEntryGetLevelMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigEntryGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigEntryGetValueMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigEntryRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data ConfigEntryUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/CredSshInteractivePrompt.hs b/GI/Ggit/Structs/CredSshInteractivePrompt.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/CredSshInteractivePrompt.hs @@ -0,0 +1,469 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a ssh interactive prompt. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.CredSshInteractivePrompt + ( + +-- * Exported types + CredSshInteractivePrompt(..) , + noCredSshInteractivePrompt , + + + -- * Methods +-- ** getInstruction #method:getInstruction# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptGetInstructionMethodInfo, +#endif + credSshInteractivePromptGetInstruction , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptGetNameMethodInfo, +#endif + credSshInteractivePromptGetName , + + +-- ** getResponse #method:getResponse# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptGetResponseMethodInfo, +#endif + credSshInteractivePromptGetResponse , + + +-- ** getText #method:getText# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptGetTextMethodInfo, +#endif + credSshInteractivePromptGetText , + + +-- ** isMasked #method:isMasked# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptIsMaskedMethodInfo, +#endif + credSshInteractivePromptIsMasked , + + +-- ** new #method:new# + + credSshInteractivePromptNew , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptRefMethodInfo , +#endif + credSshInteractivePromptRef , + + +-- ** setResponse #method:setResponse# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptSetResponseMethodInfo, +#endif + credSshInteractivePromptSetResponse , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + CredSshInteractivePromptUnrefMethodInfo , +#endif + credSshInteractivePromptUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype CredSshInteractivePrompt = CredSshInteractivePrompt (ManagedPtr CredSshInteractivePrompt) +foreign import ccall "ggit_cred_ssh_interactive_prompt_get_type" c_ggit_cred_ssh_interactive_prompt_get_type :: + IO GType + +instance BoxedObject CredSshInteractivePrompt where + boxedType _ = c_ggit_cred_ssh_interactive_prompt_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `CredSshInteractivePrompt`. +noCredSshInteractivePrompt :: Maybe CredSshInteractivePrompt +noCredSshInteractivePrompt = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CredSshInteractivePrompt +type instance O.AttributeList CredSshInteractivePrompt = CredSshInteractivePromptAttributeList +type CredSshInteractivePromptAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method CredSshInteractivePrompt::new +-- method type : Constructor +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instruction", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_masked", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_new" ggit_cred_ssh_interactive_prompt_new :: + CString -> -- name : TBasicType TUTF8 + CString -> -- instruction : TBasicType TUTF8 + CString -> -- text : TBasicType TUTF8 + CInt -> -- is_masked : TBasicType TBoolean + IO (Ptr CredSshInteractivePrompt) + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> T.Text + -> T.Text + -> Bool + -> m CredSshInteractivePrompt +credSshInteractivePromptNew name instruction text isMasked = liftIO $ do + name' <- textToCString name + instruction' <- textToCString instruction + text' <- textToCString text + let isMasked' = (fromIntegral . fromEnum) isMasked + result <- ggit_cred_ssh_interactive_prompt_new name' instruction' text' isMasked' + checkUnexpectedReturnNULL "credSshInteractivePromptNew" result + result' <- (wrapBoxed CredSshInteractivePrompt) result + freeMem name' + freeMem instruction' + freeMem text' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CredSshInteractivePrompt::get_instruction +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_get_instruction" ggit_cred_ssh_interactive_prompt_get_instruction :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptGetInstruction :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> m T.Text +credSshInteractivePromptGetInstruction prompt = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + result <- ggit_cred_ssh_interactive_prompt_get_instruction prompt' + checkUnexpectedReturnNULL "credSshInteractivePromptGetInstruction" result + result' <- cstringToText result + touchManagedPtr prompt + return result' + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetInstructionMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CredSshInteractivePromptGetInstructionMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptGetInstruction + +#endif + +-- method CredSshInteractivePrompt::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_get_name" ggit_cred_ssh_interactive_prompt_get_name :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> m T.Text +credSshInteractivePromptGetName prompt = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + result <- ggit_cred_ssh_interactive_prompt_get_name prompt' + checkUnexpectedReturnNULL "credSshInteractivePromptGetName" result + result' <- cstringToText result + touchManagedPtr prompt + return result' + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CredSshInteractivePromptGetNameMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptGetName + +#endif + +-- method CredSshInteractivePrompt::get_response +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_get_response" ggit_cred_ssh_interactive_prompt_get_response :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptGetResponse :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> m T.Text +credSshInteractivePromptGetResponse prompt = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + result <- ggit_cred_ssh_interactive_prompt_get_response prompt' + checkUnexpectedReturnNULL "credSshInteractivePromptGetResponse" result + result' <- cstringToText result + touchManagedPtr prompt + return result' + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetResponseMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CredSshInteractivePromptGetResponseMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptGetResponse + +#endif + +-- method CredSshInteractivePrompt::get_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_get_text" ggit_cred_ssh_interactive_prompt_get_text :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptGetText :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> m T.Text +credSshInteractivePromptGetText prompt = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + result <- ggit_cred_ssh_interactive_prompt_get_text prompt' + checkUnexpectedReturnNULL "credSshInteractivePromptGetText" result + result' <- cstringToText result + touchManagedPtr prompt + return result' + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CredSshInteractivePromptGetTextMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptGetText + +#endif + +-- method CredSshInteractivePrompt::is_masked +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_is_masked" ggit_cred_ssh_interactive_prompt_is_masked :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + IO CInt + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptIsMasked :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> m Bool +credSshInteractivePromptIsMasked prompt = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + result <- ggit_cred_ssh_interactive_prompt_is_masked prompt' + let result' = (/= 0) result + touchManagedPtr prompt + return result' + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptIsMaskedMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo CredSshInteractivePromptIsMaskedMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptIsMasked + +#endif + +-- method CredSshInteractivePrompt::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_ref" ggit_cred_ssh_interactive_prompt_ref :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + IO (Ptr CredSshInteractivePrompt) + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptRef :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> m CredSshInteractivePrompt +credSshInteractivePromptRef prompt = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + result <- ggit_cred_ssh_interactive_prompt_ref prompt' + checkUnexpectedReturnNULL "credSshInteractivePromptRef" result + result' <- (wrapBoxed CredSshInteractivePrompt) result + touchManagedPtr prompt + return result' + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptRefMethodInfo +instance (signature ~ (m CredSshInteractivePrompt), MonadIO m) => O.MethodInfo CredSshInteractivePromptRefMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptRef + +#endif + +-- method CredSshInteractivePrompt::set_response +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "response", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_set_response" ggit_cred_ssh_interactive_prompt_set_response :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + CString -> -- response : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptSetResponse :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> T.Text + -> m () +credSshInteractivePromptSetResponse prompt response = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + response' <- textToCString response + ggit_cred_ssh_interactive_prompt_set_response prompt' response' + touchManagedPtr prompt + freeMem response' + return () + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptSetResponseMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo CredSshInteractivePromptSetResponseMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptSetResponse + +#endif + +-- method CredSshInteractivePrompt::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "prompt", argType = TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_cred_ssh_interactive_prompt_unref" ggit_cred_ssh_interactive_prompt_unref :: + Ptr CredSshInteractivePrompt -> -- prompt : TInterface (Name {namespace = "Ggit", name = "CredSshInteractivePrompt"}) + IO () + +{- | +/No description available in the introspection data./ +-} +credSshInteractivePromptUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + CredSshInteractivePrompt + -> m () +credSshInteractivePromptUnref prompt = liftIO $ do + prompt' <- unsafeManagedPtrGetPtr prompt + ggit_cred_ssh_interactive_prompt_unref prompt' + touchManagedPtr prompt + return () + +#if ENABLE_OVERLOADING +data CredSshInteractivePromptUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo CredSshInteractivePromptUnrefMethodInfo CredSshInteractivePrompt signature where + overloadedMethod _ = credSshInteractivePromptUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveCredSshInteractivePromptMethod (t :: Symbol) (o :: *) :: * where + ResolveCredSshInteractivePromptMethod "isMasked" o = CredSshInteractivePromptIsMaskedMethodInfo + ResolveCredSshInteractivePromptMethod "ref" o = CredSshInteractivePromptRefMethodInfo + ResolveCredSshInteractivePromptMethod "unref" o = CredSshInteractivePromptUnrefMethodInfo + ResolveCredSshInteractivePromptMethod "getInstruction" o = CredSshInteractivePromptGetInstructionMethodInfo + ResolveCredSshInteractivePromptMethod "getName" o = CredSshInteractivePromptGetNameMethodInfo + ResolveCredSshInteractivePromptMethod "getResponse" o = CredSshInteractivePromptGetResponseMethodInfo + ResolveCredSshInteractivePromptMethod "getText" o = CredSshInteractivePromptGetTextMethodInfo + ResolveCredSshInteractivePromptMethod "setResponse" o = CredSshInteractivePromptSetResponseMethodInfo + ResolveCredSshInteractivePromptMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCredSshInteractivePromptMethod t CredSshInteractivePrompt, O.MethodInfo info CredSshInteractivePrompt p) => OL.IsLabel t (CredSshInteractivePrompt -> 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 + + diff --git a/GI/Ggit/Structs/CredSshInteractivePrompt.hs-boot b/GI/Ggit/Structs/CredSshInteractivePrompt.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/CredSshInteractivePrompt.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.CredSshInteractivePrompt 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 + +newtype CredSshInteractivePrompt = CredSshInteractivePrompt (ManagedPtr CredSshInteractivePrompt) +instance BoxedObject CredSshInteractivePrompt where +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetInstructionMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetResponseMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractivePromptGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractivePromptIsMaskedMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractivePromptRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractivePromptSetResponseMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredSshInteractivePromptUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/DiffBinary.hs b/GI/Ggit/Structs/DiffBinary.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffBinary.hs @@ -0,0 +1,263 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a diff binary. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.DiffBinary + ( + +-- * Exported types + DiffBinary(..) , + noDiffBinary , + + + -- * Methods +-- ** getNewFile #method:getNewFile# + +#if ENABLE_OVERLOADING + DiffBinaryGetNewFileMethodInfo , +#endif + diffBinaryGetNewFile , + + +-- ** getOldFile #method:getOldFile# + +#if ENABLE_OVERLOADING + DiffBinaryGetOldFileMethodInfo , +#endif + diffBinaryGetOldFile , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + DiffBinaryRefMethodInfo , +#endif + diffBinaryRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + DiffBinaryUnrefMethodInfo , +#endif + diffBinaryUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.DiffBinaryFile as Ggit.DiffBinaryFile + +-- | Memory-managed wrapper type. +newtype DiffBinary = DiffBinary (ManagedPtr DiffBinary) +foreign import ccall "ggit_diff_binary_get_type" c_ggit_diff_binary_get_type :: + IO GType + +instance BoxedObject DiffBinary where + boxedType _ = c_ggit_diff_binary_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffBinary`. +noDiffBinary :: Maybe DiffBinary +noDiffBinary = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffBinary +type instance O.AttributeList DiffBinary = DiffBinaryAttributeList +type DiffBinaryAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method DiffBinary::get_new_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "binary", argType = TInterface (Name {namespace = "Ggit", name = "DiffBinary"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffBinary.", 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_get_new_file" ggit_diff_binary_get_new_file :: + Ptr DiffBinary -> -- binary : TInterface (Name {namespace = "Ggit", name = "DiffBinary"}) + IO (Ptr Ggit.DiffBinaryFile.DiffBinaryFile) + +{- | +Gets the 'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile' new file for /@binary@/. +-} +diffBinaryGetNewFile :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffBinary + {- ^ /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'. -} + -> m (Maybe Ggit.DiffBinaryFile.DiffBinaryFile) + {- ^ __Returns:__ the contents of the new file or 'Nothing'. -} +diffBinaryGetNewFile binary = liftIO $ do + binary' <- unsafeManagedPtrGetPtr binary + result <- ggit_diff_binary_get_new_file binary' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.DiffBinaryFile.DiffBinaryFile) result' + return result'' + touchManagedPtr binary + return maybeResult + +#if ENABLE_OVERLOADING +data DiffBinaryGetNewFileMethodInfo +instance (signature ~ (m (Maybe Ggit.DiffBinaryFile.DiffBinaryFile)), MonadIO m) => O.MethodInfo DiffBinaryGetNewFileMethodInfo DiffBinary signature where + overloadedMethod _ = diffBinaryGetNewFile + +#endif + +-- method DiffBinary::get_old_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "binary", argType = TInterface (Name {namespace = "Ggit", name = "DiffBinary"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffBinary.", 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_get_old_file" ggit_diff_binary_get_old_file :: + Ptr DiffBinary -> -- binary : TInterface (Name {namespace = "Ggit", name = "DiffBinary"}) + IO (Ptr Ggit.DiffBinaryFile.DiffBinaryFile) + +{- | +Gets the 'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile' old file for /@binary@/. +-} +diffBinaryGetOldFile :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffBinary + {- ^ /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'. -} + -> m (Maybe Ggit.DiffBinaryFile.DiffBinaryFile) + {- ^ __Returns:__ the contents of the old file or 'Nothing'. -} +diffBinaryGetOldFile binary = liftIO $ do + binary' <- unsafeManagedPtrGetPtr binary + result <- ggit_diff_binary_get_old_file binary' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.DiffBinaryFile.DiffBinaryFile) result' + return result'' + touchManagedPtr binary + return maybeResult + +#if ENABLE_OVERLOADING +data DiffBinaryGetOldFileMethodInfo +instance (signature ~ (m (Maybe Ggit.DiffBinaryFile.DiffBinaryFile)), MonadIO m) => O.MethodInfo DiffBinaryGetOldFileMethodInfo DiffBinary signature where + overloadedMethod _ = diffBinaryGetOldFile + +#endif + +-- method DiffBinary::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "binary", argType = TInterface (Name {namespace = "Ggit", name = "DiffBinary"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffBinary.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffBinary"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_binary_ref" ggit_diff_binary_ref :: + Ptr DiffBinary -> -- binary : TInterface (Name {namespace = "Ggit", name = "DiffBinary"}) + IO (Ptr DiffBinary) + +{- | +Atomically increments the reference count of /@binary@/ by one. +This function is MT-safe and may be called from any thread. +-} +diffBinaryRef :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffBinary + {- ^ /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'. -} + -> m (Maybe DiffBinary) + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffBinary.DiffBinary' or 'Nothing'. -} +diffBinaryRef binary = liftIO $ do + binary' <- unsafeManagedPtrGetPtr binary + result <- ggit_diff_binary_ref binary' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed DiffBinary) result' + return result'' + touchManagedPtr binary + return maybeResult + +#if ENABLE_OVERLOADING +data DiffBinaryRefMethodInfo +instance (signature ~ (m (Maybe DiffBinary)), MonadIO m) => O.MethodInfo DiffBinaryRefMethodInfo DiffBinary signature where + overloadedMethod _ = diffBinaryRef + +#endif + +-- method DiffBinary::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "binary", argType = TInterface (Name {namespace = "Ggit", name = "DiffBinary"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffBinary.", 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_unref" ggit_diff_binary_unref :: + Ptr DiffBinary -> -- binary : TInterface (Name {namespace = "Ggit", name = "DiffBinary"}) + IO () + +{- | +Atomically decrements the reference count of /@binary@/ by one. +If the reference count drops to 0, /@binary@/ is freed. +-} +diffBinaryUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffBinary + {- ^ /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'. -} + -> m () +diffBinaryUnref binary = liftIO $ do + binary' <- unsafeManagedPtrGetPtr binary + ggit_diff_binary_unref binary' + touchManagedPtr binary + return () + +#if ENABLE_OVERLOADING +data DiffBinaryUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffBinaryUnrefMethodInfo DiffBinary signature where + overloadedMethod _ = diffBinaryUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffBinaryMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffBinaryMethod "ref" o = DiffBinaryRefMethodInfo + ResolveDiffBinaryMethod "unref" o = DiffBinaryUnrefMethodInfo + ResolveDiffBinaryMethod "getNewFile" o = DiffBinaryGetNewFileMethodInfo + ResolveDiffBinaryMethod "getOldFile" o = DiffBinaryGetOldFileMethodInfo + ResolveDiffBinaryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffBinaryMethod t DiffBinary, O.MethodInfo info DiffBinary p) => OL.IsLabel t (DiffBinary -> 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 + + diff --git a/GI/Ggit/Structs/DiffBinary.hs-boot b/GI/Ggit/Structs/DiffBinary.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffBinary.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.DiffBinary 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 + +newtype DiffBinary = DiffBinary (ManagedPtr DiffBinary) +instance BoxedObject DiffBinary where +#if ENABLE_OVERLOADING +data DiffBinaryGetNewFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBinaryGetOldFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBinaryRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBinaryUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/DiffBinaryFile.hs b/GI/Ggit/Structs/DiffBinaryFile.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffBinaryFile.hs @@ -0,0 +1,303 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a diff binary file. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.DiffBinaryFile + ( + +-- * Exported types + DiffBinaryFile(..) , + noDiffBinaryFile , + + + -- * Methods +-- ** getBinaryType #method:getBinaryType# + +#if ENABLE_OVERLOADING + DiffBinaryFileGetBinaryTypeMethodInfo , +#endif + diffBinaryFileGetBinaryType , + + +-- ** getData #method:getData# + +#if ENABLE_OVERLOADING + DiffBinaryFileGetDataMethodInfo , +#endif + diffBinaryFileGetData , + + +-- ** getInflatedSize #method:getInflatedSize# + +#if ENABLE_OVERLOADING + DiffBinaryFileGetInflatedSizeMethodInfo , +#endif + diffBinaryFileGetInflatedSize , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + DiffBinaryFileRefMethodInfo , +#endif + diffBinaryFileRef , + + +-- ** unref #method:unref# + +#if 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.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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums + +-- | Memory-managed wrapper type. +newtype DiffBinaryFile = DiffBinaryFile (ManagedPtr DiffBinaryFile) +foreign import ccall "ggit_diff_binary_file_get_type" c_ggit_diff_binary_file_get_type :: + IO GType + +instance BoxedObject DiffBinaryFile where + boxedType _ = c_ggit_diff_binary_file_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffBinaryFile`. +noDiffBinaryFile :: Maybe DiffBinaryFile +noDiffBinaryFile = Nothing + + +#if 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 'GI.Ggit.Enums.DiffBinaryType' for /@file@/. +-} +diffBinaryFileGetBinaryType :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffBinaryFile + {- ^ /@file@/: a 'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'. -} + -> m Ggit.Enums.DiffBinaryType + {- ^ __Returns:__ the file\'s binary type. -} +diffBinaryFileGetBinaryType file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_binary_file_get_binary_type file' + let result' = (toEnum . fromIntegral) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data DiffBinaryFileGetBinaryTypeMethodInfo +instance (signature ~ (m Ggit.Enums.DiffBinaryType), MonadIO m) => O.MethodInfo DiffBinaryFileGetBinaryTypeMethodInfo DiffBinaryFile signature where + overloadedMethod _ = 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 'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'. -} + -> Word64 + {- ^ /@size@/: location to return size of byte data. -} + -> m Word8 + {- ^ __Returns:__ a pointer to the binary data, or 'Nothing'. -} +diffBinaryFileGetData file size = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_binary_file_get_data file' size + touchManagedPtr file + return result + +#if ENABLE_OVERLOADING +data DiffBinaryFileGetDataMethodInfo +instance (signature ~ (Word64 -> m Word8), MonadIO m) => O.MethodInfo DiffBinaryFileGetDataMethodInfo DiffBinaryFile signature where + overloadedMethod _ = 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 'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'. -} + -> m Word64 + {- ^ __Returns:__ the length of the binary data after inflation. -} +diffBinaryFileGetInflatedSize file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_binary_file_get_inflated_size file' + touchManagedPtr file + return result + +#if ENABLE_OVERLOADING +data DiffBinaryFileGetInflatedSizeMethodInfo +instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo DiffBinaryFileGetInflatedSizeMethodInfo DiffBinaryFile signature where + overloadedMethod _ = 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 'GI.Ggit.Objects.Diff.Diff'. -} + -> m DiffBinaryFile + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'. -} +diffBinaryFileRef file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_binary_file_ref file' + checkUnexpectedReturnNULL "diffBinaryFileRef" result + result' <- (wrapBoxed DiffBinaryFile) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data DiffBinaryFileRefMethodInfo +instance (signature ~ (m DiffBinaryFile), MonadIO m) => O.MethodInfo DiffBinaryFileRefMethodInfo DiffBinaryFile signature where + overloadedMethod _ = 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 'GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile'. -} + -> m () +diffBinaryFileUnref file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + ggit_diff_binary_file_unref file' + touchManagedPtr file + return () + +#if ENABLE_OVERLOADING +data DiffBinaryFileUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffBinaryFileUnrefMethodInfo DiffBinaryFile signature where + overloadedMethod _ = diffBinaryFileUnref + +#endif + +#if 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.MethodInfo info DiffBinaryFile p) => OL.IsLabel t (DiffBinaryFile -> 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 + + diff --git a/GI/Ggit/Structs/DiffBinaryFile.hs-boot b/GI/Ggit/Structs/DiffBinaryFile.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffBinaryFile.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.DiffBinaryFile 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 + +newtype DiffBinaryFile = DiffBinaryFile (ManagedPtr DiffBinaryFile) +instance BoxedObject DiffBinaryFile where +#if ENABLE_OVERLOADING +data DiffBinaryFileGetBinaryTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBinaryFileGetDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBinaryFileGetInflatedSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBinaryFileRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffBinaryFileUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/DiffDelta.hs b/GI/Ggit/Structs/DiffDelta.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffDelta.hs @@ -0,0 +1,396 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the changes done to one file. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.DiffDelta + ( + +-- * Exported types + DiffDelta(..) , + noDiffDelta , + + + -- * Methods +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + DiffDeltaGetFlagsMethodInfo , +#endif + diffDeltaGetFlags , + + +-- ** getNewFile #method:getNewFile# + +#if ENABLE_OVERLOADING + DiffDeltaGetNewFileMethodInfo , +#endif + diffDeltaGetNewFile , + + +-- ** getOldFile #method:getOldFile# + +#if ENABLE_OVERLOADING + DiffDeltaGetOldFileMethodInfo , +#endif + diffDeltaGetOldFile , + + +-- ** getSimilarity #method:getSimilarity# + +#if ENABLE_OVERLOADING + DiffDeltaGetSimilarityMethodInfo , +#endif + diffDeltaGetSimilarity , + + +-- ** getStatus #method:getStatus# + +#if ENABLE_OVERLOADING + DiffDeltaGetStatusMethodInfo , +#endif + diffDeltaGetStatus , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + DiffDeltaRefMethodInfo , +#endif + diffDeltaRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + DiffDeltaUnrefMethodInfo , +#endif + diffDeltaUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffFile as Ggit.DiffFile + +-- | Memory-managed wrapper type. +newtype DiffDelta = DiffDelta (ManagedPtr DiffDelta) +foreign import ccall "ggit_diff_delta_get_type" c_ggit_diff_delta_get_type :: + IO GType + +instance BoxedObject DiffDelta where + boxedType _ = c_ggit_diff_delta_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffDelta`. +noDiffDelta :: Maybe DiffDelta +noDiffDelta = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffDelta +type instance O.AttributeList DiffDelta = DiffDeltaAttributeList +type DiffDeltaAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method DiffDelta::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFlag"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_delta_get_flags" ggit_diff_delta_get_flags :: + Ptr DiffDelta -> -- delta : TInterface (Name {namespace = "Ggit", name = "DiffDelta"}) + IO CUInt + +{- | +Gets flags for /@delta@/. +-} +diffDeltaGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> m [Ggit.Flags.DiffFlag] + {- ^ __Returns:__ the delta flags -} +diffDeltaGetFlags delta = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + result <- ggit_diff_delta_get_flags delta' + let result' = wordToGFlags result + touchManagedPtr delta + return result' + +#if ENABLE_OVERLOADING +data DiffDeltaGetFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.DiffFlag]), MonadIO m) => O.MethodInfo DiffDeltaGetFlagsMethodInfo DiffDelta signature where + overloadedMethod _ = diffDeltaGetFlags + +#endif + +-- method DiffDelta::get_new_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_delta_get_new_file" ggit_diff_delta_get_new_file :: + Ptr DiffDelta -> -- delta : TInterface (Name {namespace = "Ggit", name = "DiffDelta"}) + IO (Ptr Ggit.DiffFile.DiffFile) + +{- | +Gets the new file for /@delta@/. +-} +diffDeltaGetNewFile :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> m (Maybe Ggit.DiffFile.DiffFile) + {- ^ __Returns:__ the delta\'s new file or 'Nothing'. -} +diffDeltaGetNewFile delta = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + result <- ggit_diff_delta_get_new_file delta' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.DiffFile.DiffFile) result' + return result'' + touchManagedPtr delta + return maybeResult + +#if ENABLE_OVERLOADING +data DiffDeltaGetNewFileMethodInfo +instance (signature ~ (m (Maybe Ggit.DiffFile.DiffFile)), MonadIO m) => O.MethodInfo DiffDeltaGetNewFileMethodInfo DiffDelta signature where + overloadedMethod _ = diffDeltaGetNewFile + +#endif + +-- method DiffDelta::get_old_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_delta_get_old_file" ggit_diff_delta_get_old_file :: + Ptr DiffDelta -> -- delta : TInterface (Name {namespace = "Ggit", name = "DiffDelta"}) + IO (Ptr Ggit.DiffFile.DiffFile) + +{- | +Gets the old file for /@delta@/. +-} +diffDeltaGetOldFile :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> m (Maybe Ggit.DiffFile.DiffFile) + {- ^ __Returns:__ the delta\'s old file or 'Nothing'. -} +diffDeltaGetOldFile delta = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + result <- ggit_diff_delta_get_old_file delta' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.DiffFile.DiffFile) result' + return result'' + touchManagedPtr delta + return maybeResult + +#if ENABLE_OVERLOADING +data DiffDeltaGetOldFileMethodInfo +instance (signature ~ (m (Maybe Ggit.DiffFile.DiffFile)), MonadIO m) => O.MethodInfo DiffDeltaGetOldFileMethodInfo DiffDelta signature where + overloadedMethod _ = diffDeltaGetOldFile + +#endif + +-- method DiffDelta::get_similarity +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_delta_get_similarity" ggit_diff_delta_get_similarity :: + Ptr DiffDelta -> -- delta : TInterface (Name {namespace = "Ggit", name = "DiffDelta"}) + IO Word32 + +{- | +Gets the similarity between /@delta@/ files. +-} +diffDeltaGetSimilarity :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> m Word32 + {- ^ __Returns:__ the delta\'s similarity. -} +diffDeltaGetSimilarity delta = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + result <- ggit_diff_delta_get_similarity delta' + touchManagedPtr delta + return result + +#if ENABLE_OVERLOADING +data DiffDeltaGetSimilarityMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo DiffDeltaGetSimilarityMethodInfo DiffDelta signature where + overloadedMethod _ = diffDeltaGetSimilarity + +#endif + +-- method DiffDelta::get_status +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DeltaType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_delta_get_status" ggit_diff_delta_get_status :: + Ptr DiffDelta -> -- delta : TInterface (Name {namespace = "Ggit", name = "DiffDelta"}) + IO CUInt + +{- | +Gets the 'GI.Ggit.Enums.DeltaType' for /@delta@/. +-} +diffDeltaGetStatus :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> m Ggit.Enums.DeltaType + {- ^ __Returns:__ the delta\'s status. -} +diffDeltaGetStatus delta = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + result <- ggit_diff_delta_get_status delta' + let result' = (toEnum . fromIntegral) result + touchManagedPtr delta + return result' + +#if ENABLE_OVERLOADING +data DiffDeltaGetStatusMethodInfo +instance (signature ~ (m Ggit.Enums.DeltaType), MonadIO m) => O.MethodInfo DiffDeltaGetStatusMethodInfo DiffDelta signature where + overloadedMethod _ = diffDeltaGetStatus + +#endif + +-- method DiffDelta::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffDelta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_delta_ref" ggit_diff_delta_ref :: + Ptr DiffDelta -> -- delta : TInterface (Name {namespace = "Ggit", name = "DiffDelta"}) + IO (Ptr DiffDelta) + +{- | +Atomically increments the reference count of /@delta@/ by one. +This function is MT-safe and may be called from any thread. +-} +diffDeltaRef :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> m (Maybe DiffDelta) + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffDelta.DiffDelta' or 'Nothing'. -} +diffDeltaRef delta = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + result <- ggit_diff_delta_ref delta' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed DiffDelta) result' + return result'' + touchManagedPtr delta + return maybeResult + +#if ENABLE_OVERLOADING +data DiffDeltaRefMethodInfo +instance (signature ~ (m (Maybe DiffDelta)), MonadIO m) => O.MethodInfo DiffDeltaRefMethodInfo DiffDelta signature where + overloadedMethod _ = diffDeltaRef + +#endif + +-- method DiffDelta::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "delta", argType = TInterface (Name {namespace = "Ggit", name = "DiffDelta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffDelta.", 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_delta_unref" ggit_diff_delta_unref :: + Ptr DiffDelta -> -- delta : TInterface (Name {namespace = "Ggit", name = "DiffDelta"}) + IO () + +{- | +Atomically decrements the reference count of /@delta@/ by one. +If the reference count drops to 0, /@delta@/ is freed. +-} +diffDeltaUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffDelta + {- ^ /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'. -} + -> m () +diffDeltaUnref delta = liftIO $ do + delta' <- unsafeManagedPtrGetPtr delta + ggit_diff_delta_unref delta' + touchManagedPtr delta + return () + +#if ENABLE_OVERLOADING +data DiffDeltaUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffDeltaUnrefMethodInfo DiffDelta signature where + overloadedMethod _ = diffDeltaUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffDeltaMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffDeltaMethod "ref" o = DiffDeltaRefMethodInfo + ResolveDiffDeltaMethod "unref" o = DiffDeltaUnrefMethodInfo + ResolveDiffDeltaMethod "getFlags" o = DiffDeltaGetFlagsMethodInfo + ResolveDiffDeltaMethod "getNewFile" o = DiffDeltaGetNewFileMethodInfo + ResolveDiffDeltaMethod "getOldFile" o = DiffDeltaGetOldFileMethodInfo + ResolveDiffDeltaMethod "getSimilarity" o = DiffDeltaGetSimilarityMethodInfo + ResolveDiffDeltaMethod "getStatus" o = DiffDeltaGetStatusMethodInfo + ResolveDiffDeltaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffDeltaMethod t DiffDelta, O.MethodInfo info DiffDelta p) => OL.IsLabel t (DiffDelta -> 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 + + diff --git a/GI/Ggit/Structs/DiffDelta.hs-boot b/GI/Ggit/Structs/DiffDelta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffDelta.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.DiffDelta 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 + +newtype DiffDelta = DiffDelta (ManagedPtr DiffDelta) +instance BoxedObject DiffDelta where +#if ENABLE_OVERLOADING +data DiffDeltaGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffDeltaGetNewFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffDeltaGetOldFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffDeltaGetSimilarityMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffDeltaGetStatusMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffDeltaRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffDeltaUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/DiffFile.hs b/GI/Ggit/Structs/DiffFile.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffFile.hs @@ -0,0 +1,394 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a file in a 'GI.Ggit.Objects.Diff.Diff'. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.DiffFile + ( + +-- * Exported types + DiffFile(..) , + noDiffFile , + + + -- * Methods +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + DiffFileGetFlagsMethodInfo , +#endif + diffFileGetFlags , + + +-- ** getMode #method:getMode# + +#if ENABLE_OVERLOADING + DiffFileGetModeMethodInfo , +#endif + diffFileGetMode , + + +-- ** getOid #method:getOid# + +#if ENABLE_OVERLOADING + DiffFileGetOidMethodInfo , +#endif + diffFileGetOid , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + DiffFileGetPathMethodInfo , +#endif + diffFileGetPath , + + +-- ** getSize #method:getSize# + +#if ENABLE_OVERLOADING + DiffFileGetSizeMethodInfo , +#endif + diffFileGetSize , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + DiffFileRefMethodInfo , +#endif + diffFileRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + DiffFileUnrefMethodInfo , +#endif + diffFileUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype DiffFile = DiffFile (ManagedPtr DiffFile) +foreign import ccall "ggit_diff_file_get_type" c_ggit_diff_file_get_type :: + IO GType + +instance BoxedObject DiffFile where + boxedType _ = c_ggit_diff_file_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffFile`. +noDiffFile :: Maybe DiffFile +noDiffFile = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffFile +type instance O.AttributeList DiffFile = DiffFileAttributeList +type DiffFileAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method DiffFile::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffFlag"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_file_get_flags" ggit_diff_file_get_flags :: + Ptr DiffFile -> -- file : TInterface (Name {namespace = "Ggit", name = "DiffFile"}) + IO CUInt + +{- | +Gets the @/GgitDifflags/@ for /@file@/. +-} +diffFileGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffFile + {- ^ /@file@/: a 'GI.Ggit.Structs.DiffFile.DiffFile'. -} + -> m [Ggit.Flags.DiffFlag] + {- ^ __Returns:__ the file\'s flags. -} +diffFileGetFlags file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_file_get_flags file' + let result' = wordToGFlags result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data DiffFileGetFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.DiffFlag]), MonadIO m) => O.MethodInfo DiffFileGetFlagsMethodInfo DiffFile signature where + overloadedMethod _ = diffFileGetFlags + +#endif + +-- method DiffFile::get_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt16) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_file_get_mode" ggit_diff_file_get_mode :: + Ptr DiffFile -> -- file : TInterface (Name {namespace = "Ggit", name = "DiffFile"}) + IO Word16 + +{- | +Gets the mode for /@file@/. +-} +diffFileGetMode :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffFile + {- ^ /@file@/: a 'GI.Ggit.Structs.DiffFile.DiffFile'. -} + -> m Word16 + {- ^ __Returns:__ the file\'s mode. -} +diffFileGetMode file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_file_get_mode file' + touchManagedPtr file + return result + +#if ENABLE_OVERLOADING +data DiffFileGetModeMethodInfo +instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo DiffFileGetModeMethodInfo DiffFile signature where + overloadedMethod _ = diffFileGetMode + +#endif + +-- method DiffFile::get_oid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_file_get_oid" ggit_diff_file_get_oid :: + Ptr DiffFile -> -- file : TInterface (Name {namespace = "Ggit", name = "DiffFile"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the 'GI.Ggit.Structs.OId.OId' for /@file@/. +-} +diffFileGetOid :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffFile + {- ^ /@file@/: a 'GI.Ggit.Structs.DiffFile.DiffFile'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the file\'s 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +diffFileGetOid file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_file_get_oid file' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr file + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFileGetOidMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo DiffFileGetOidMethodInfo DiffFile signature where + overloadedMethod _ = diffFileGetOid + +#endif + +-- method DiffFile::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_file_get_path" ggit_diff_file_get_path :: + Ptr DiffFile -> -- file : TInterface (Name {namespace = "Ggit", name = "DiffFile"}) + IO CString + +{- | +Gets the path of /@file@/ or 'Nothing' if it is unknown. +-} +diffFileGetPath :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffFile + {- ^ /@file@/: a 'GI.Ggit.Structs.DiffFile.DiffFile'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the file\'s path, or 'Nothing'. -} +diffFileGetPath file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_file_get_path file' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr file + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFileGetPathMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo DiffFileGetPathMethodInfo DiffFile signature where + overloadedMethod _ = diffFileGetPath + +#endif + +-- method DiffFile::get_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_file_get_size" ggit_diff_file_get_size :: + Ptr DiffFile -> -- file : TInterface (Name {namespace = "Ggit", name = "DiffFile"}) + IO Int64 + +{- | +Gets the size for /@file@/. +-} +diffFileGetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffFile + {- ^ /@file@/: a 'GI.Ggit.Structs.DiffFile.DiffFile'. -} + -> m Int64 + {- ^ __Returns:__ the file\'s size. -} +diffFileGetSize file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_file_get_size file' + touchManagedPtr file + return result + +#if ENABLE_OVERLOADING +data DiffFileGetSizeMethodInfo +instance (signature ~ (m Int64), MonadIO m) => O.MethodInfo DiffFileGetSizeMethodInfo DiffFile signature where + overloadedMethod _ = diffFileGetSize + +#endif + +-- method DiffFile::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), 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 = "DiffFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_file_ref" ggit_diff_file_ref :: + Ptr DiffFile -> -- file : TInterface (Name {namespace = "Ggit", name = "DiffFile"}) + IO (Ptr DiffFile) + +{- | +Atomically increments the reference count of /@file@/ by one. +This function is MT-safe and may be called from any thread. +-} +diffFileRef :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffFile + {- ^ /@file@/: a 'GI.Ggit.Objects.Diff.Diff'. -} + -> m (Maybe DiffFile) + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffFile.DiffFile' or 'Nothing'. -} +diffFileRef file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + result <- ggit_diff_file_ref file' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed DiffFile) result' + return result'' + touchManagedPtr file + return maybeResult + +#if ENABLE_OVERLOADING +data DiffFileRefMethodInfo +instance (signature ~ (m (Maybe DiffFile)), MonadIO m) => O.MethodInfo DiffFileRefMethodInfo DiffFile signature where + overloadedMethod _ = diffFileRef + +#endif + +-- method DiffFile::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Ggit", name = "DiffFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffFile.", 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_file_unref" ggit_diff_file_unref :: + Ptr DiffFile -> -- file : TInterface (Name {namespace = "Ggit", name = "DiffFile"}) + IO () + +{- | +Atomically decrements the reference count of /@file@/ by one. +If the reference count drops to 0, /@file@/ is freed. +-} +diffFileUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffFile + {- ^ /@file@/: a 'GI.Ggit.Structs.DiffFile.DiffFile'. -} + -> m () +diffFileUnref file = liftIO $ do + file' <- unsafeManagedPtrGetPtr file + ggit_diff_file_unref file' + touchManagedPtr file + return () + +#if ENABLE_OVERLOADING +data DiffFileUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffFileUnrefMethodInfo DiffFile signature where + overloadedMethod _ = diffFileUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffFileMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffFileMethod "ref" o = DiffFileRefMethodInfo + ResolveDiffFileMethod "unref" o = DiffFileUnrefMethodInfo + ResolveDiffFileMethod "getFlags" o = DiffFileGetFlagsMethodInfo + ResolveDiffFileMethod "getMode" o = DiffFileGetModeMethodInfo + ResolveDiffFileMethod "getOid" o = DiffFileGetOidMethodInfo + ResolveDiffFileMethod "getPath" o = DiffFileGetPathMethodInfo + ResolveDiffFileMethod "getSize" o = DiffFileGetSizeMethodInfo + ResolveDiffFileMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffFileMethod t DiffFile, O.MethodInfo info DiffFile p) => OL.IsLabel t (DiffFile -> 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 + + diff --git a/GI/Ggit/Structs/DiffFile.hs-boot b/GI/Ggit/Structs/DiffFile.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffFile.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.DiffFile 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 + +newtype DiffFile = DiffFile (ManagedPtr DiffFile) +instance BoxedObject DiffFile where +#if ENABLE_OVERLOADING +data DiffFileGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFileGetModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFileGetOidMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFileGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFileGetSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFileRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffFileUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/DiffHunk.hs b/GI/Ggit/Structs/DiffHunk.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffHunk.hs @@ -0,0 +1,385 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the hunk of a diff. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.DiffHunk + ( + +-- * Exported types + DiffHunk(..) , + noDiffHunk , + + + -- * Methods +-- ** getHeader #method:getHeader# + +#if ENABLE_OVERLOADING + DiffHunkGetHeaderMethodInfo , +#endif + diffHunkGetHeader , + + +-- ** getNewLines #method:getNewLines# + +#if ENABLE_OVERLOADING + DiffHunkGetNewLinesMethodInfo , +#endif + diffHunkGetNewLines , + + +-- ** getNewStart #method:getNewStart# + +#if ENABLE_OVERLOADING + DiffHunkGetNewStartMethodInfo , +#endif + diffHunkGetNewStart , + + +-- ** getOldLines #method:getOldLines# + +#if ENABLE_OVERLOADING + DiffHunkGetOldLinesMethodInfo , +#endif + diffHunkGetOldLines , + + +-- ** getOldStart #method:getOldStart# + +#if ENABLE_OVERLOADING + DiffHunkGetOldStartMethodInfo , +#endif + diffHunkGetOldStart , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + DiffHunkRefMethodInfo , +#endif + diffHunkRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + DiffHunkUnrefMethodInfo , +#endif + diffHunkUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype DiffHunk = DiffHunk (ManagedPtr DiffHunk) +foreign import ccall "ggit_diff_hunk_get_type" c_ggit_diff_hunk_get_type :: + IO GType + +instance BoxedObject DiffHunk where + boxedType _ = c_ggit_diff_hunk_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffHunk`. +noDiffHunk :: Maybe DiffHunk +noDiffHunk = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffHunk +type instance O.AttributeList DiffHunk = DiffHunkAttributeList +type DiffHunkAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method DiffHunk::get_header +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_hunk_get_header" ggit_diff_hunk_get_header :: + Ptr DiffHunk -> -- hunk : TInterface (Name {namespace = "Ggit", name = "DiffHunk"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +diffHunkGetHeader :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffHunk + -> m T.Text +diffHunkGetHeader hunk = liftIO $ do + hunk' <- unsafeManagedPtrGetPtr hunk + result <- ggit_diff_hunk_get_header hunk' + checkUnexpectedReturnNULL "diffHunkGetHeader" result + result' <- cstringToText result + touchManagedPtr hunk + return result' + +#if ENABLE_OVERLOADING +data DiffHunkGetHeaderMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo DiffHunkGetHeaderMethodInfo DiffHunk signature where + overloadedMethod _ = diffHunkGetHeader + +#endif + +-- method DiffHunk::get_new_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_hunk_get_new_lines" ggit_diff_hunk_get_new_lines :: + Ptr DiffHunk -> -- hunk : TInterface (Name {namespace = "Ggit", name = "DiffHunk"}) + IO Int32 + +{- | +Gets the number of lines in the new file. +-} +diffHunkGetNewLines :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> m Int32 + {- ^ __Returns:__ the number of lines in the new file. -} +diffHunkGetNewLines hunk = liftIO $ do + hunk' <- unsafeManagedPtrGetPtr hunk + result <- ggit_diff_hunk_get_new_lines hunk' + touchManagedPtr hunk + return result + +#if ENABLE_OVERLOADING +data DiffHunkGetNewLinesMethodInfo +instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DiffHunkGetNewLinesMethodInfo DiffHunk signature where + overloadedMethod _ = diffHunkGetNewLines + +#endif + +-- method DiffHunk::get_new_start +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_hunk_get_new_start" ggit_diff_hunk_get_new_start :: + Ptr DiffHunk -> -- hunk : TInterface (Name {namespace = "Ggit", name = "DiffHunk"}) + IO Int32 + +{- | +Gets the starting line number in the new file. +-} +diffHunkGetNewStart :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> m Int32 + {- ^ __Returns:__ the starting line number in the new file. -} +diffHunkGetNewStart hunk = liftIO $ do + hunk' <- unsafeManagedPtrGetPtr hunk + result <- ggit_diff_hunk_get_new_start hunk' + touchManagedPtr hunk + return result + +#if ENABLE_OVERLOADING +data DiffHunkGetNewStartMethodInfo +instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DiffHunkGetNewStartMethodInfo DiffHunk signature where + overloadedMethod _ = diffHunkGetNewStart + +#endif + +-- method DiffHunk::get_old_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_hunk_get_old_lines" ggit_diff_hunk_get_old_lines :: + Ptr DiffHunk -> -- hunk : TInterface (Name {namespace = "Ggit", name = "DiffHunk"}) + IO Int32 + +{- | +Gets the number of lines in the old file. +-} +diffHunkGetOldLines :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> m Int32 + {- ^ __Returns:__ the number of lines in the old file. -} +diffHunkGetOldLines hunk = liftIO $ do + hunk' <- unsafeManagedPtrGetPtr hunk + result <- ggit_diff_hunk_get_old_lines hunk' + touchManagedPtr hunk + return result + +#if ENABLE_OVERLOADING +data DiffHunkGetOldLinesMethodInfo +instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DiffHunkGetOldLinesMethodInfo DiffHunk signature where + overloadedMethod _ = diffHunkGetOldLines + +#endif + +-- method DiffHunk::get_old_start +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_hunk_get_old_start" ggit_diff_hunk_get_old_start :: + Ptr DiffHunk -> -- hunk : TInterface (Name {namespace = "Ggit", name = "DiffHunk"}) + IO Int32 + +{- | +Gets the starting line number in the old file. +-} +diffHunkGetOldStart :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> m Int32 + {- ^ __Returns:__ the starting line number in the old file. -} +diffHunkGetOldStart hunk = liftIO $ do + hunk' <- unsafeManagedPtrGetPtr hunk + result <- ggit_diff_hunk_get_old_start hunk' + touchManagedPtr hunk + return result + +#if ENABLE_OVERLOADING +data DiffHunkGetOldStartMethodInfo +instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DiffHunkGetOldStartMethodInfo DiffHunk signature where + overloadedMethod _ = diffHunkGetOldStart + +#endif + +-- method DiffHunk::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffHunk"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_hunk_ref" ggit_diff_hunk_ref :: + Ptr DiffHunk -> -- hunk : TInterface (Name {namespace = "Ggit", name = "DiffHunk"}) + IO (Ptr DiffHunk) + +{- | +Atomically increments the reference count of /@hunk@/ by one. +This function is MT-safe and may be called from any thread. +-} +diffHunkRef :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> m (Maybe DiffHunk) + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffHunk.DiffHunk' or 'Nothing'. -} +diffHunkRef hunk = liftIO $ do + hunk' <- unsafeManagedPtrGetPtr hunk + result <- ggit_diff_hunk_ref hunk' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed DiffHunk) result' + return result'' + touchManagedPtr hunk + return maybeResult + +#if ENABLE_OVERLOADING +data DiffHunkRefMethodInfo +instance (signature ~ (m (Maybe DiffHunk)), MonadIO m) => O.MethodInfo DiffHunkRefMethodInfo DiffHunk signature where + overloadedMethod _ = diffHunkRef + +#endif + +-- method DiffHunk::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hunk", argType = TInterface (Name {namespace = "Ggit", name = "DiffHunk"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffHunk.", 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_hunk_unref" ggit_diff_hunk_unref :: + Ptr DiffHunk -> -- hunk : TInterface (Name {namespace = "Ggit", name = "DiffHunk"}) + IO () + +{- | +Atomically decrements the reference count of /@hunk@/ by one. +If the reference count drops to 0, /@hunk@/ is freed. +-} +diffHunkUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffHunk + {- ^ /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'. -} + -> m () +diffHunkUnref hunk = liftIO $ do + hunk' <- unsafeManagedPtrGetPtr hunk + ggit_diff_hunk_unref hunk' + touchManagedPtr hunk + return () + +#if ENABLE_OVERLOADING +data DiffHunkUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffHunkUnrefMethodInfo DiffHunk signature where + overloadedMethod _ = diffHunkUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffHunkMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffHunkMethod "ref" o = DiffHunkRefMethodInfo + ResolveDiffHunkMethod "unref" o = DiffHunkUnrefMethodInfo + ResolveDiffHunkMethod "getHeader" o = DiffHunkGetHeaderMethodInfo + ResolveDiffHunkMethod "getNewLines" o = DiffHunkGetNewLinesMethodInfo + ResolveDiffHunkMethod "getNewStart" o = DiffHunkGetNewStartMethodInfo + ResolveDiffHunkMethod "getOldLines" o = DiffHunkGetOldLinesMethodInfo + ResolveDiffHunkMethod "getOldStart" o = DiffHunkGetOldStartMethodInfo + ResolveDiffHunkMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffHunkMethod t DiffHunk, O.MethodInfo info DiffHunk p) => OL.IsLabel t (DiffHunk -> 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 + + diff --git a/GI/Ggit/Structs/DiffHunk.hs-boot b/GI/Ggit/Structs/DiffHunk.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffHunk.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.DiffHunk 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 + +newtype DiffHunk = DiffHunk (ManagedPtr DiffHunk) +instance BoxedObject DiffHunk where +#if ENABLE_OVERLOADING +data DiffHunkGetHeaderMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffHunkGetNewLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffHunkGetNewStartMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffHunkGetOldLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffHunkGetOldStartMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffHunkRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffHunkUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/DiffLine.hs b/GI/Ggit/Structs/DiffLine.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffLine.hs @@ -0,0 +1,439 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the line of a diff. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.DiffLine + ( + +-- * Exported types + DiffLine(..) , + noDiffLine , + + + -- * Methods +-- ** getContent #method:getContent# + +#if ENABLE_OVERLOADING + DiffLineGetContentMethodInfo , +#endif + diffLineGetContent , + + +-- ** getContentOffset #method:getContentOffset# + +#if ENABLE_OVERLOADING + DiffLineGetContentOffsetMethodInfo , +#endif + diffLineGetContentOffset , + + +-- ** getNewLineno #method:getNewLineno# + +#if ENABLE_OVERLOADING + DiffLineGetNewLinenoMethodInfo , +#endif + diffLineGetNewLineno , + + +-- ** getOldLineno #method:getOldLineno# + +#if ENABLE_OVERLOADING + DiffLineGetOldLinenoMethodInfo , +#endif + diffLineGetOldLineno , + + +-- ** getOrigin #method:getOrigin# + +#if ENABLE_OVERLOADING + DiffLineGetOriginMethodInfo , +#endif + diffLineGetOrigin , + + +-- ** getText #method:getText# + +#if ENABLE_OVERLOADING + DiffLineGetTextMethodInfo , +#endif + diffLineGetText , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + DiffLineRefMethodInfo , +#endif + diffLineRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + DiffLineUnrefMethodInfo , +#endif + diffLineUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums + +-- | Memory-managed wrapper type. +newtype DiffLine = DiffLine (ManagedPtr DiffLine) +foreign import ccall "ggit_diff_line_get_type" c_ggit_diff_line_get_type :: + IO GType + +instance BoxedObject DiffLine where + boxedType _ = c_ggit_diff_line_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffLine`. +noDiffLine :: Maybe DiffLine +noDiffLine = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffLine +type instance O.AttributeList DiffLine = DiffLineAttributeList +type DiffLineAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method DiffLine::get_content +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of returned bytes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of returned bytes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (TCArray False (-1) 1 (TBasicType TUInt8)) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_line_get_content" ggit_diff_line_get_content :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + Ptr Word64 -> -- length : TBasicType TUInt64 + IO (Ptr Word8) + +{- | +Gets the content in bytes. +-} +diffLineGetContent :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m ByteString + {- ^ __Returns:__ the content in bytes. -} +diffLineGetContent line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + length_ <- allocMem :: IO (Ptr Word64) + result <- ggit_diff_line_get_content line' length_ + length_' <- peek length_ + checkUnexpectedReturnNULL "diffLineGetContent" result + result' <- (unpackByteStringWithLength length_') result + touchManagedPtr line + freeMem length_ + return result' + +#if ENABLE_OVERLOADING +data DiffLineGetContentMethodInfo +instance (signature ~ (m ByteString), MonadIO m) => O.MethodInfo DiffLineGetContentMethodInfo DiffLine signature where + overloadedMethod _ = diffLineGetContent + +#endif + +-- method DiffLine::get_content_offset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_line_get_content_offset" ggit_diff_line_get_content_offset :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + IO Int64 + +{- | +Gets the content offset. +-} +diffLineGetContentOffset :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m Int64 + {- ^ __Returns:__ the content offset. -} +diffLineGetContentOffset line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + result <- ggit_diff_line_get_content_offset line' + touchManagedPtr line + return result + +#if ENABLE_OVERLOADING +data DiffLineGetContentOffsetMethodInfo +instance (signature ~ (m Int64), MonadIO m) => O.MethodInfo DiffLineGetContentOffsetMethodInfo DiffLine signature where + overloadedMethod _ = diffLineGetContentOffset + +#endif + +-- method DiffLine::get_new_lineno +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_line_get_new_lineno" ggit_diff_line_get_new_lineno :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + IO Int32 + +{- | +Gets the Line number in new file or -1 for deleted line. +-} +diffLineGetNewLineno :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m Int32 + {- ^ __Returns:__ the line\'s old number of lines. -} +diffLineGetNewLineno line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + result <- ggit_diff_line_get_new_lineno line' + touchManagedPtr line + return result + +#if ENABLE_OVERLOADING +data DiffLineGetNewLinenoMethodInfo +instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DiffLineGetNewLinenoMethodInfo DiffLine signature where + overloadedMethod _ = diffLineGetNewLineno + +#endif + +-- method DiffLine::get_old_lineno +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_line_get_old_lineno" ggit_diff_line_get_old_lineno :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + IO Int32 + +{- | +Gets the line number in old file or -1 for added line. +-} +diffLineGetOldLineno :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m Int32 + {- ^ __Returns:__ the line\'s old line number. -} +diffLineGetOldLineno line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + result <- ggit_diff_line_get_old_lineno line' + touchManagedPtr line + return result + +#if ENABLE_OVERLOADING +data DiffLineGetOldLinenoMethodInfo +instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo DiffLineGetOldLinenoMethodInfo DiffLine signature where + overloadedMethod _ = diffLineGetOldLineno + +#endif + +-- method DiffLine::get_origin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffLineType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_line_get_origin" ggit_diff_line_get_origin :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + IO CUInt + +{- | +Gets the 'GI.Ggit.Enums.DiffLineType' value. +-} +diffLineGetOrigin :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m Ggit.Enums.DiffLineType + {- ^ __Returns:__ the 'GI.Ggit.Enums.DiffLineType' value. -} +diffLineGetOrigin line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + result <- ggit_diff_line_get_origin line' + let result' = (toEnum . fromIntegral) result + touchManagedPtr line + return result' + +#if ENABLE_OVERLOADING +data DiffLineGetOriginMethodInfo +instance (signature ~ (m Ggit.Enums.DiffLineType), MonadIO m) => O.MethodInfo DiffLineGetOriginMethodInfo DiffLine signature where + overloadedMethod _ = diffLineGetOrigin + +#endif + +-- method DiffLine::get_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_line_get_text" ggit_diff_line_get_text :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + IO CString + +{- | +Get the content of the diff line as UTF-8 encoded text. +-} +diffLineGetText :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the content in utf-8 encoding or 'Nothing'. -} +diffLineGetText line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + result <- ggit_diff_line_get_text line' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr line + return maybeResult + +#if ENABLE_OVERLOADING +data DiffLineGetTextMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo DiffLineGetTextMethodInfo DiffLine signature where + overloadedMethod _ = diffLineGetText + +#endif + +-- method DiffLine::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffLine"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_line_ref" ggit_diff_line_ref :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + IO (Ptr DiffLine) + +{- | +Atomically increments the reference count of /@line@/ by one. +This function is MT-safe and may be called from any thread. +-} +diffLineRef :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m (Maybe DiffLine) + {- ^ __Returns:__ a 'GI.Ggit.Structs.DiffLine.DiffLine' or 'Nothing'. -} +diffLineRef line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + result <- ggit_diff_line_ref line' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed DiffLine) result' + return result'' + touchManagedPtr line + return maybeResult + +#if ENABLE_OVERLOADING +data DiffLineRefMethodInfo +instance (signature ~ (m (Maybe DiffLine)), MonadIO m) => O.MethodInfo DiffLineRefMethodInfo DiffLine signature where + overloadedMethod _ = diffLineRef + +#endif + +-- method DiffLine::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Ggit", name = "DiffLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffLine.", 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_line_unref" ggit_diff_line_unref :: + Ptr DiffLine -> -- line : TInterface (Name {namespace = "Ggit", name = "DiffLine"}) + IO () + +{- | +Atomically decrements the reference count of /@line@/ by one. +If the reference count drops to 0, /@line@/ is freed. +-} +diffLineUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffLine + {- ^ /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'. -} + -> m () +diffLineUnref line = liftIO $ do + line' <- unsafeManagedPtrGetPtr line + ggit_diff_line_unref line' + touchManagedPtr line + return () + +#if ENABLE_OVERLOADING +data DiffLineUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffLineUnrefMethodInfo DiffLine signature where + overloadedMethod _ = diffLineUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffLineMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffLineMethod "ref" o = DiffLineRefMethodInfo + ResolveDiffLineMethod "unref" o = DiffLineUnrefMethodInfo + ResolveDiffLineMethod "getContent" o = DiffLineGetContentMethodInfo + ResolveDiffLineMethod "getContentOffset" o = DiffLineGetContentOffsetMethodInfo + ResolveDiffLineMethod "getNewLineno" o = DiffLineGetNewLinenoMethodInfo + ResolveDiffLineMethod "getOldLineno" o = DiffLineGetOldLinenoMethodInfo + ResolveDiffLineMethod "getOrigin" o = DiffLineGetOriginMethodInfo + ResolveDiffLineMethod "getText" o = DiffLineGetTextMethodInfo + ResolveDiffLineMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffLineMethod t DiffLine, O.MethodInfo info DiffLine p) => OL.IsLabel t (DiffLine -> 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 + + diff --git a/GI/Ggit/Structs/DiffLine.hs-boot b/GI/Ggit/Structs/DiffLine.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffLine.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.DiffLine 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 + +newtype DiffLine = DiffLine (ManagedPtr DiffLine) +instance BoxedObject DiffLine where +#if ENABLE_OVERLOADING +data DiffLineGetContentMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffLineGetContentOffsetMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffLineGetNewLinenoMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffLineGetOldLinenoMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffLineGetOriginMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffLineGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffLineRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffLineUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/DiffSimilarityMetric.hs b/GI/Ggit/Structs/DiffSimilarityMetric.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffSimilarityMetric.hs @@ -0,0 +1,223 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a similarity metric. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.DiffSimilarityMetric + ( + +-- * Exported types + DiffSimilarityMetric(..) , + noDiffSimilarityMetric , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + DiffSimilarityMetricCopyMethodInfo , +#endif + diffSimilarityMetricCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + DiffSimilarityMetricFreeMethodInfo , +#endif + diffSimilarityMetricFree , + + +-- ** new #method:new# + + diffSimilarityMetricNew , + + + + + ) 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.Ggit.Callbacks as Ggit.Callbacks + +-- | Memory-managed wrapper type. +newtype DiffSimilarityMetric = DiffSimilarityMetric (ManagedPtr DiffSimilarityMetric) +foreign import ccall "ggit_diff_similarity_metric_get_type" c_ggit_diff_similarity_metric_get_type :: + IO GType + +instance BoxedObject DiffSimilarityMetric where + boxedType _ = c_ggit_diff_similarity_metric_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `DiffSimilarityMetric`. +noDiffSimilarityMetric :: Maybe DiffSimilarityMetric +noDiffSimilarityMetric = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DiffSimilarityMetric +type instance O.AttributeList DiffSimilarityMetric = DiffSimilarityMetricAttributeList +type DiffSimilarityMetricAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method DiffSimilarityMetric::new +-- method type : Constructor +-- Args : [Arg {argCName = "file_signature", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricFileSignatureCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetricFileSignature.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer_signature", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricBufferSignatureCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetricBufferSignature.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "free_signature", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricFreeSignatureCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetricFreeSignature.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "similarity", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricSimilarityCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetricSimilarity.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "passed as user_data to the previous parameters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_similarity_metric_new" ggit_diff_similarity_metric_new :: + FunPtr Ggit.Callbacks.C_DiffSimilarityMetricFileSignatureCallback -> -- file_signature : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricFileSignatureCallback"}) + FunPtr Ggit.Callbacks.C_DiffSimilarityMetricBufferSignatureCallback -> -- buffer_signature : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricBufferSignatureCallback"}) + FunPtr Ggit.Callbacks.C_DiffSimilarityMetricFreeSignatureCallback -> -- free_signature : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricFreeSignatureCallback"}) + FunPtr Ggit.Callbacks.C_DiffSimilarityMetricSimilarityCallback -> -- similarity : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetricSimilarityCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO (Ptr DiffSimilarityMetric) + +{- | +Creates a new 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric'. +-} +diffSimilarityMetricNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Ggit.Callbacks.DiffSimilarityMetricFileSignatureCallback + {- ^ /@fileSignature@/: a @/GgitDiffSimilarityMetricFileSignature/@. -} + -> Ggit.Callbacks.DiffSimilarityMetricBufferSignatureCallback + {- ^ /@bufferSignature@/: a @/GgitDiffSimilarityMetricBufferSignature/@. -} + -> Ggit.Callbacks.DiffSimilarityMetricFreeSignatureCallback + {- ^ /@freeSignature@/: a @/GgitDiffSimilarityMetricFreeSignature/@. -} + -> Ggit.Callbacks.DiffSimilarityMetricSimilarityCallback + {- ^ /@similarity@/: a @/GgitDiffSimilarityMetricSimilarity/@. -} + -> m DiffSimilarityMetric + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric'. -} +diffSimilarityMetricNew fileSignature bufferSignature freeSignature similarity = liftIO $ do + fileSignature' <- Ggit.Callbacks.mk_DiffSimilarityMetricFileSignatureCallback (Ggit.Callbacks.wrap_DiffSimilarityMetricFileSignatureCallback Nothing (Ggit.Callbacks.drop_closures_DiffSimilarityMetricFileSignatureCallback fileSignature)) + bufferSignature' <- Ggit.Callbacks.mk_DiffSimilarityMetricBufferSignatureCallback (Ggit.Callbacks.wrap_DiffSimilarityMetricBufferSignatureCallback Nothing (Ggit.Callbacks.drop_closures_DiffSimilarityMetricBufferSignatureCallback bufferSignature)) + freeSignature' <- Ggit.Callbacks.mk_DiffSimilarityMetricFreeSignatureCallback (Ggit.Callbacks.wrap_DiffSimilarityMetricFreeSignatureCallback Nothing (Ggit.Callbacks.drop_closures_DiffSimilarityMetricFreeSignatureCallback freeSignature)) + similarity' <- Ggit.Callbacks.mk_DiffSimilarityMetricSimilarityCallback (Ggit.Callbacks.wrap_DiffSimilarityMetricSimilarityCallback Nothing (Ggit.Callbacks.drop_closures_DiffSimilarityMetricSimilarityCallback similarity)) + let userData = nullPtr + result <- ggit_diff_similarity_metric_new fileSignature' bufferSignature' freeSignature' similarity' userData + checkUnexpectedReturnNULL "diffSimilarityMetricNew" result + result' <- (wrapBoxed DiffSimilarityMetric) result + safeFreeFunPtr $ castFunPtrToPtr fileSignature' + safeFreeFunPtr $ castFunPtrToPtr bufferSignature' + safeFreeFunPtr $ castFunPtrToPtr freeSignature' + safeFreeFunPtr $ castFunPtrToPtr similarity' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method DiffSimilarityMetric::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "metric", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetric.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_diff_similarity_metric_copy" ggit_diff_similarity_metric_copy :: + Ptr DiffSimilarityMetric -> -- metric : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}) + IO (Ptr DiffSimilarityMetric) + +{- | +Copies /@metric@/ into a newly allocated 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric'. +-} +diffSimilarityMetricCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffSimilarityMetric + {- ^ /@metric@/: a 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric'. -} + -> m (Maybe DiffSimilarityMetric) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric' or 'Nothing'. -} +diffSimilarityMetricCopy metric = liftIO $ do + metric' <- unsafeManagedPtrGetPtr metric + result <- ggit_diff_similarity_metric_copy metric' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed DiffSimilarityMetric) result' + return result'' + touchManagedPtr metric + return maybeResult + +#if ENABLE_OVERLOADING +data DiffSimilarityMetricCopyMethodInfo +instance (signature ~ (m (Maybe DiffSimilarityMetric)), MonadIO m) => O.MethodInfo DiffSimilarityMetricCopyMethodInfo DiffSimilarityMetric signature where + overloadedMethod _ = diffSimilarityMetricCopy + +#endif + +-- method DiffSimilarityMetric::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "metric", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiffSimilarityMetric.", 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_similarity_metric_free" ggit_diff_similarity_metric_free :: + Ptr DiffSimilarityMetric -> -- metric : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}) + IO () + +{- | +Frees /@metric@/. +-} +diffSimilarityMetricFree :: + (B.CallStack.HasCallStack, MonadIO m) => + DiffSimilarityMetric + {- ^ /@metric@/: a 'GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric'. -} + -> m () +diffSimilarityMetricFree metric = liftIO $ do + metric' <- unsafeManagedPtrGetPtr metric + ggit_diff_similarity_metric_free metric' + touchManagedPtr metric + return () + +#if ENABLE_OVERLOADING +data DiffSimilarityMetricFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffSimilarityMetricFreeMethodInfo DiffSimilarityMetric signature where + overloadedMethod _ = diffSimilarityMetricFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDiffSimilarityMetricMethod (t :: Symbol) (o :: *) :: * where + ResolveDiffSimilarityMetricMethod "copy" o = DiffSimilarityMetricCopyMethodInfo + ResolveDiffSimilarityMetricMethod "free" o = DiffSimilarityMetricFreeMethodInfo + ResolveDiffSimilarityMetricMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDiffSimilarityMetricMethod t DiffSimilarityMetric, O.MethodInfo info DiffSimilarityMetric p) => OL.IsLabel t (DiffSimilarityMetric -> 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 + + diff --git a/GI/Ggit/Structs/DiffSimilarityMetric.hs-boot b/GI/Ggit/Structs/DiffSimilarityMetric.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/DiffSimilarityMetric.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.DiffSimilarityMetric 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 + +newtype DiffSimilarityMetric = DiffSimilarityMetric (ManagedPtr DiffSimilarityMetric) +instance BoxedObject DiffSimilarityMetric where +#if ENABLE_OVERLOADING +data DiffSimilarityMetricCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data DiffSimilarityMetricFreeMethodInfo +#endif diff --git a/GI/Ggit/Structs/FetchOptions.hs b/GI/Ggit/Structs/FetchOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/FetchOptions.hs @@ -0,0 +1,389 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git fetch options. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.FetchOptions + ( + +-- * Exported types + FetchOptions(..) , + noFetchOptions , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + FetchOptionsCopyMethodInfo , +#endif + fetchOptionsCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + FetchOptionsFreeMethodInfo , +#endif + fetchOptionsFree , + + +-- ** getDownloadTags #method:getDownloadTags# + +#if ENABLE_OVERLOADING + FetchOptionsGetDownloadTagsMethodInfo , +#endif + fetchOptionsGetDownloadTags , + + +-- ** getRemoteCallbacks #method:getRemoteCallbacks# + +#if ENABLE_OVERLOADING + FetchOptionsGetRemoteCallbacksMethodInfo, +#endif + fetchOptionsGetRemoteCallbacks , + + +-- ** new #method:new# + + fetchOptionsNew , + + +-- ** setDownloadTags #method:setDownloadTags# + +#if ENABLE_OVERLOADING + FetchOptionsSetDownloadTagsMethodInfo , +#endif + fetchOptionsSetDownloadTags , + + +-- ** setRemoteCallbacks #method:setRemoteCallbacks# + +#if ENABLE_OVERLOADING + FetchOptionsSetRemoteCallbacksMethodInfo, +#endif + fetchOptionsSetRemoteCallbacks , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Objects.RemoteCallbacks as Ggit.RemoteCallbacks + +-- | Memory-managed wrapper type. +newtype FetchOptions = FetchOptions (ManagedPtr FetchOptions) +foreign import ccall "ggit_fetch_options_get_type" c_ggit_fetch_options_get_type :: + IO GType + +instance BoxedObject FetchOptions where + boxedType _ = c_ggit_fetch_options_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `FetchOptions`. +noFetchOptions :: Maybe FetchOptions +noFetchOptions = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FetchOptions +type instance O.AttributeList FetchOptions = FetchOptionsAttributeList +type FetchOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method FetchOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "FetchOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_fetch_options_new" ggit_fetch_options_new :: + IO (Ptr FetchOptions) + +{- | +Creates a new 'GI.Ggit.Structs.FetchOptions.FetchOptions'. +-} +fetchOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m FetchOptions + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} +fetchOptionsNew = liftIO $ do + result <- ggit_fetch_options_new + checkUnexpectedReturnNULL "fetchOptionsNew" result + result' <- (wrapBoxed FetchOptions) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method FetchOptions::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "fetch_options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "FetchOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_fetch_options_copy" ggit_fetch_options_copy :: + Ptr FetchOptions -> -- fetch_options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + IO (Ptr FetchOptions) + +{- | +Copies /@fetchOptions@/ into a newly allocated 'GI.Ggit.Structs.FetchOptions.FetchOptions'. +-} +fetchOptionsCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + FetchOptions + {- ^ /@fetchOptions@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> m (Maybe FetchOptions) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.FetchOptions.FetchOptions' or 'Nothing'. -} +fetchOptionsCopy fetchOptions = liftIO $ do + fetchOptions' <- unsafeManagedPtrGetPtr fetchOptions + result <- ggit_fetch_options_copy fetchOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed FetchOptions) result' + return result'' + touchManagedPtr fetchOptions + return maybeResult + +#if ENABLE_OVERLOADING +data FetchOptionsCopyMethodInfo +instance (signature ~ (m (Maybe FetchOptions)), MonadIO m) => O.MethodInfo FetchOptionsCopyMethodInfo FetchOptions signature where + overloadedMethod _ = fetchOptionsCopy + +#endif + +-- method FetchOptions::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "fetch_options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_fetch_options_free" ggit_fetch_options_free :: + Ptr FetchOptions -> -- fetch_options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + IO () + +{- | +Frees /@fetchOptions@/. +-} +fetchOptionsFree :: + (B.CallStack.HasCallStack, MonadIO m) => + FetchOptions + {- ^ /@fetchOptions@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> m () +fetchOptionsFree fetchOptions = liftIO $ do + fetchOptions' <- unsafeManagedPtrGetPtr fetchOptions + ggit_fetch_options_free fetchOptions' + touchManagedPtr fetchOptions + return () + +#if ENABLE_OVERLOADING +data FetchOptionsFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo FetchOptionsFreeMethodInfo FetchOptions signature where + overloadedMethod _ = fetchOptionsFree + +#endif + +-- method FetchOptions::get_download_tags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RemoteDownloadTagsType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_fetch_options_get_download_tags" ggit_fetch_options_get_download_tags :: + Ptr FetchOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + IO CUInt + +{- | +Get how tags are being handled when fetching\/downloading. +-} +fetchOptionsGetDownloadTags :: + (B.CallStack.HasCallStack, MonadIO m) => + FetchOptions + {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> m Ggit.Enums.RemoteDownloadTagsType + {- ^ __Returns:__ a 'GI.Ggit.Enums.RemoteDownloadTagsType'. -} +fetchOptionsGetDownloadTags options = liftIO $ do + options' <- unsafeManagedPtrGetPtr options + result <- ggit_fetch_options_get_download_tags options' + let result' = (toEnum . fromIntegral) result + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data FetchOptionsGetDownloadTagsMethodInfo +instance (signature ~ (m Ggit.Enums.RemoteDownloadTagsType), MonadIO m) => O.MethodInfo FetchOptionsGetDownloadTagsMethodInfo FetchOptions signature where + overloadedMethod _ = fetchOptionsGetDownloadTags + +#endif + +-- method FetchOptions::get_remote_callbacks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_fetch_options_get_remote_callbacks" ggit_fetch_options_get_remote_callbacks :: + Ptr FetchOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + IO (Ptr Ggit.RemoteCallbacks.RemoteCallbacks) + +{- | +Get the remote callbacks object or 'Nothing' if not set. +-} +fetchOptionsGetRemoteCallbacks :: + (B.CallStack.HasCallStack, MonadIO m) => + FetchOptions + {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks) + {- ^ __Returns:__ the remote callbacks or 'Nothing'. -} +fetchOptionsGetRemoteCallbacks options = liftIO $ do + options' <- unsafeManagedPtrGetPtr options + result <- ggit_fetch_options_get_remote_callbacks options' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.RemoteCallbacks.RemoteCallbacks) result' + return result'' + touchManagedPtr options + return maybeResult + +#if ENABLE_OVERLOADING +data FetchOptionsGetRemoteCallbacksMethodInfo +instance (signature ~ (m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)), MonadIO m) => O.MethodInfo FetchOptionsGetRemoteCallbacksMethodInfo FetchOptions signature where + overloadedMethod _ = fetchOptionsGetRemoteCallbacks + +#endif + +-- method FetchOptions::set_download_tags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "download_tags", argType = TInterface (Name {namespace = "Ggit", name = "RemoteDownloadTagsType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemoteDownloadTagsType.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_fetch_options_set_download_tags" ggit_fetch_options_set_download_tags :: + Ptr FetchOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + CUInt -> -- download_tags : TInterface (Name {namespace = "Ggit", name = "RemoteDownloadTagsType"}) + IO () + +{- | +Set how tags are being handled when fetching\/downloading. +-} +fetchOptionsSetDownloadTags :: + (B.CallStack.HasCallStack, MonadIO m) => + FetchOptions + {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> Ggit.Enums.RemoteDownloadTagsType + {- ^ /@downloadTags@/: a 'GI.Ggit.Enums.RemoteDownloadTagsType'. -} + -> m () +fetchOptionsSetDownloadTags options downloadTags = liftIO $ do + options' <- unsafeManagedPtrGetPtr options + let downloadTags' = (fromIntegral . fromEnum) downloadTags + ggit_fetch_options_set_download_tags options' downloadTags' + touchManagedPtr options + return () + +#if ENABLE_OVERLOADING +data FetchOptionsSetDownloadTagsMethodInfo +instance (signature ~ (Ggit.Enums.RemoteDownloadTagsType -> m ()), MonadIO m) => O.MethodInfo FetchOptionsSetDownloadTagsMethodInfo FetchOptions signature where + overloadedMethod _ = fetchOptionsSetDownloadTags + +#endif + +-- method FetchOptions::set_remote_callbacks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callbacks", argType = TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitRemoteCallbacks or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_fetch_options_set_remote_callbacks" ggit_fetch_options_set_remote_callbacks :: + Ptr FetchOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"}) + Ptr Ggit.RemoteCallbacks.RemoteCallbacks -> -- callbacks : TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"}) + IO () + +{- | +Set the fetch options object. +-} +fetchOptionsSetRemoteCallbacks :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => + FetchOptions + {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -} + -> Maybe (a) + {- ^ /@callbacks@/: a 'GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks' or 'Nothing'. -} + -> m () +fetchOptionsSetRemoteCallbacks options callbacks = liftIO $ do + options' <- unsafeManagedPtrGetPtr options + maybeCallbacks <- case callbacks of + Nothing -> return nullPtr + Just jCallbacks -> do + jCallbacks' <- unsafeManagedPtrCastPtr jCallbacks + return jCallbacks' + ggit_fetch_options_set_remote_callbacks options' maybeCallbacks + touchManagedPtr options + whenJust callbacks touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data FetchOptionsSetRemoteCallbacksMethodInfo +instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => O.MethodInfo FetchOptionsSetRemoteCallbacksMethodInfo FetchOptions signature where + overloadedMethod _ = fetchOptionsSetRemoteCallbacks + +#endif + +#if ENABLE_OVERLOADING +type family ResolveFetchOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveFetchOptionsMethod "copy" o = FetchOptionsCopyMethodInfo + ResolveFetchOptionsMethod "free" o = FetchOptionsFreeMethodInfo + ResolveFetchOptionsMethod "getDownloadTags" o = FetchOptionsGetDownloadTagsMethodInfo + ResolveFetchOptionsMethod "getRemoteCallbacks" o = FetchOptionsGetRemoteCallbacksMethodInfo + ResolveFetchOptionsMethod "setDownloadTags" o = FetchOptionsSetDownloadTagsMethodInfo + ResolveFetchOptionsMethod "setRemoteCallbacks" o = FetchOptionsSetRemoteCallbacksMethodInfo + ResolveFetchOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFetchOptionsMethod t FetchOptions, O.MethodInfo info FetchOptions p) => OL.IsLabel t (FetchOptions -> 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 + + diff --git a/GI/Ggit/Structs/FetchOptions.hs-boot b/GI/Ggit/Structs/FetchOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/FetchOptions.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.FetchOptions 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 + +newtype FetchOptions = FetchOptions (ManagedPtr FetchOptions) +instance BoxedObject FetchOptions where +#if ENABLE_OVERLOADING +data FetchOptionsCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data FetchOptionsFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FetchOptionsGetDownloadTagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FetchOptionsGetRemoteCallbacksMethodInfo +#endif +#if ENABLE_OVERLOADING +data FetchOptionsSetDownloadTagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FetchOptionsSetRemoteCallbacksMethodInfo +#endif diff --git a/GI/Ggit/Structs/IndexEntries.hs b/GI/Ggit/Structs/IndexEntries.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntries.hs @@ -0,0 +1,341 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the entries in an index object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.IndexEntries + ( + +-- * Exported types + IndexEntries(..) , + noIndexEntries , + + + -- * Methods +-- ** getByIndex #method:getByIndex# + +#if ENABLE_OVERLOADING + IndexEntriesGetByIndexMethodInfo , +#endif + indexEntriesGetByIndex , + + +-- ** getByPath #method:getByPath# + +#if ENABLE_OVERLOADING + IndexEntriesGetByPathMethodInfo , +#endif + indexEntriesGetByPath , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + IndexEntriesRefMethodInfo , +#endif + indexEntriesRef , + + +-- ** size #method:size# + +#if ENABLE_OVERLOADING + IndexEntriesSizeMethodInfo , +#endif + indexEntriesSize , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + IndexEntriesUnrefMethodInfo , +#endif + indexEntriesUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntry as Ggit.IndexEntry +import qualified GI.Gio.Interfaces.File as Gio.File + +-- | Memory-managed wrapper type. +newtype IndexEntries = IndexEntries (ManagedPtr IndexEntries) +foreign import ccall "ggit_index_entries_get_type" c_ggit_index_entries_get_type :: + IO GType + +instance BoxedObject IndexEntries where + boxedType _ = c_ggit_index_entries_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `IndexEntries`. +noIndexEntries :: Maybe IndexEntries +noIndexEntries = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList IndexEntries +type instance O.AttributeList IndexEntries = IndexEntriesAttributeList +type IndexEntriesAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method IndexEntries::get_by_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the entry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_get_by_index" ggit_index_entries_get_by_index :: + Ptr IndexEntries -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"}) + Word64 -> -- idx : TBasicType TUInt64 + IO (Ptr Ggit.IndexEntry.IndexEntry) + +{- | +Get a 'GI.Ggit.Structs.IndexEntry.IndexEntry' by index. Note that the returned 'GI.Ggit.Structs.IndexEntry.IndexEntry' is +_only_ valid as long as: + +1) The associated index has been closed +2) The entry has not been removed (see 'GI.Ggit.Objects.Index.indexRemove') +3) The index has not been refreshed (see 'GI.Ggit.Objects.Index.indexRead') + +Changes to the 'GI.Ggit.Structs.IndexEntry.IndexEntry' will be reflected in the index once written +back to disk using 'GI.Ggit.Objects.Index.indexWrite'. +-} +indexEntriesGetByIndex :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntries + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -} + -> Word64 + {- ^ /@idx@/: the index of the entry. -} + -> m (Maybe Ggit.IndexEntry.IndexEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntry.IndexEntry' or 'Nothing' if out of bounds. -} +indexEntriesGetByIndex entries idx = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + result <- ggit_index_entries_get_by_index entries' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntry.IndexEntry) result' + return result'' + touchManagedPtr entries + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntriesGetByIndexMethodInfo +instance (signature ~ (Word64 -> m (Maybe Ggit.IndexEntry.IndexEntry)), MonadIO m) => O.MethodInfo IndexEntriesGetByIndexMethodInfo IndexEntries signature where + overloadedMethod _ = indexEntriesGetByIndex + +#endif + +-- method IndexEntries::get_by_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path to search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stage", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "stage to search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_get_by_path" ggit_index_entries_get_by_path :: + Ptr IndexEntries -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Int32 -> -- stage : TBasicType TInt + IO (Ptr Ggit.IndexEntry.IndexEntry) + +{- | +Get a 'GI.Ggit.Structs.IndexEntry.IndexEntry' by index. Note that the returned 'GI.Ggit.Structs.IndexEntry.IndexEntry' is +_only_ valid as long as: + +1) The associated index has not been closed +2) The entry has not been removed (see 'GI.Ggit.Objects.Index.indexRemove') +3) The index has not been refreshed (see 'GI.Ggit.Objects.Index.indexRead') + +Changes to the 'GI.Ggit.Structs.IndexEntry.IndexEntry' will be reflected in the index once written +back to disk using 'GI.Ggit.Objects.Index.indexWrite'. + +/@stage@/ indicates the stage to search the file for. Stages are used in the +index when merge conflicts occur, such that multiple versions of the same +file can be represented in the index. Stage 0 is associated with the working +tree, while stages 1 to 3 are associated with the various versions of the +file in a merge conflict. The special value -1 can be used to match the first +file encountered in any stage. +-} +indexEntriesGetByPath :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + IndexEntries + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -} + -> a + {- ^ /@file@/: the path to search. -} + -> Int32 + {- ^ /@stage@/: stage to search. -} + -> m (Maybe Ggit.IndexEntry.IndexEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntry.IndexEntry' or 'Nothing' if it was not found. -} +indexEntriesGetByPath entries file stage = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + file' <- unsafeManagedPtrCastPtr file + result <- ggit_index_entries_get_by_path entries' file' stage + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntry.IndexEntry) result' + return result'' + touchManagedPtr entries + touchManagedPtr file + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntriesGetByPathMethodInfo +instance (signature ~ (a -> Int32 -> m (Maybe Ggit.IndexEntry.IndexEntry)), MonadIO m, Gio.File.IsFile a) => O.MethodInfo IndexEntriesGetByPathMethodInfo IndexEntries signature where + overloadedMethod _ = indexEntriesGetByPath + +#endif + +-- method IndexEntries::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntries"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_ref" ggit_index_entries_ref :: + Ptr IndexEntries -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"}) + IO (Ptr IndexEntries) + +{- | +Atomically increments the reference count of /@entries@/ by one. +This function is MT-safe and may be called from any thread. +-} +indexEntriesRef :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntries + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -} + -> m (Maybe IndexEntries) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntries.IndexEntries' or 'Nothing'. -} +indexEntriesRef entries = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + result <- ggit_index_entries_ref entries' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed IndexEntries) result' + return result'' + touchManagedPtr entries + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntriesRefMethodInfo +instance (signature ~ (m (Maybe IndexEntries)), MonadIO m) => O.MethodInfo IndexEntriesRefMethodInfo IndexEntries signature where + overloadedMethod _ = indexEntriesRef + +#endif + +-- method IndexEntries::size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_size" ggit_index_entries_size :: + Ptr IndexEntries -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"}) + IO Word32 + +{- | +Get the number of 'GI.Ggit.Structs.IndexEntry.IndexEntry' entries. +-} +indexEntriesSize :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntries + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -} + -> m Word32 + {- ^ __Returns:__ the number of entries. -} +indexEntriesSize entries = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + result <- ggit_index_entries_size entries' + touchManagedPtr entries + return result + +#if ENABLE_OVERLOADING +data IndexEntriesSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntriesSizeMethodInfo IndexEntries signature where + overloadedMethod _ = indexEntriesSize + +#endif + +-- method IndexEntries::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_unref" ggit_index_entries_unref :: + Ptr IndexEntries -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"}) + IO () + +{- | +Atomically decrements the reference count of /@entries@/ by one. +If the reference count drops to 0, /@entries@/ is freed. +-} +indexEntriesUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntries + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -} + -> m () +indexEntriesUnref entries = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + ggit_index_entries_unref entries' + touchManagedPtr entries + return () + +#if ENABLE_OVERLOADING +data IndexEntriesUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IndexEntriesUnrefMethodInfo IndexEntries signature where + overloadedMethod _ = indexEntriesUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveIndexEntriesMethod (t :: Symbol) (o :: *) :: * where + ResolveIndexEntriesMethod "ref" o = IndexEntriesRefMethodInfo + ResolveIndexEntriesMethod "size" o = IndexEntriesSizeMethodInfo + ResolveIndexEntriesMethod "unref" o = IndexEntriesUnrefMethodInfo + ResolveIndexEntriesMethod "getByIndex" o = IndexEntriesGetByIndexMethodInfo + ResolveIndexEntriesMethod "getByPath" o = IndexEntriesGetByPathMethodInfo + ResolveIndexEntriesMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIndexEntriesMethod t IndexEntries, O.MethodInfo info IndexEntries p) => OL.IsLabel t (IndexEntries -> 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 + + diff --git a/GI/Ggit/Structs/IndexEntries.hs-boot b/GI/Ggit/Structs/IndexEntries.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntries.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.IndexEntries 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 + +newtype IndexEntries = IndexEntries (ManagedPtr IndexEntries) +instance BoxedObject IndexEntries where +#if ENABLE_OVERLOADING +data IndexEntriesGetByIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesGetByPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/IndexEntriesResolveUndo.hs b/GI/Ggit/Structs/IndexEntriesResolveUndo.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntriesResolveUndo.hs @@ -0,0 +1,322 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the resolve undo entries in an index object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.IndexEntriesResolveUndo + ( + +-- * Exported types + IndexEntriesResolveUndo(..) , + noIndexEntriesResolveUndo , + + + -- * Methods +-- ** get #method:get# + +#if ENABLE_OVERLOADING + IndexEntriesResolveUndoGetMethodInfo , +#endif + indexEntriesResolveUndoGet , + + +-- ** getByFile #method:getByFile# + +#if ENABLE_OVERLOADING + IndexEntriesResolveUndoGetByFileMethodInfo, +#endif + indexEntriesResolveUndoGetByFile , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + IndexEntriesResolveUndoRefMethodInfo , +#endif + indexEntriesResolveUndoRef , + + +-- ** size #method:size# + +#if ENABLE_OVERLOADING + IndexEntriesResolveUndoSizeMethodInfo , +#endif + indexEntriesResolveUndoSize , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + IndexEntriesResolveUndoUnrefMethodInfo , +#endif + indexEntriesResolveUndoUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntryResolveUndo as Ggit.IndexEntryResolveUndo +import qualified GI.Gio.Interfaces.File as Gio.File + +-- | Memory-managed wrapper type. +newtype IndexEntriesResolveUndo = IndexEntriesResolveUndo (ManagedPtr IndexEntriesResolveUndo) +foreign import ccall "ggit_index_entries_resolve_undo_get_type" c_ggit_index_entries_resolve_undo_get_type :: + IO GType + +instance BoxedObject IndexEntriesResolveUndo where + boxedType _ = c_ggit_index_entries_resolve_undo_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `IndexEntriesResolveUndo`. +noIndexEntriesResolveUndo :: Maybe IndexEntriesResolveUndo +noIndexEntriesResolveUndo = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList IndexEntriesResolveUndo +type instance O.AttributeList IndexEntriesResolveUndo = IndexEntriesResolveUndoAttributeList +type IndexEntriesResolveUndoAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method IndexEntriesResolveUndo::get +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntriesResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the entry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_resolve_undo_get" ggit_index_entries_resolve_undo_get :: + Ptr IndexEntriesResolveUndo -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}) + Word32 -> -- idx : TBasicType TUInt + IO (Ptr Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo) + +{- | +Get a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo' by index. Note that the returned +'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo' is _only_ valid as long as: + +1) The associated index has been closed +2) The entry has not been removed (see 'GI.Ggit.Objects.Index.indexRemove') +3) The index has not been refreshed (see 'GI.Ggit.Objects.Index.indexRead') +-} +indexEntriesResolveUndoGet :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntriesResolveUndo + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo'. -} + -> Word32 + {- ^ /@idx@/: the index of the entry. -} + -> m (Maybe Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo' or 'Nothing'. -} +indexEntriesResolveUndoGet entries idx = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + result <- ggit_index_entries_resolve_undo_get entries' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo) result' + return result'' + touchManagedPtr entries + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoGetMethodInfo +instance (signature ~ (Word32 -> m (Maybe Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo)), MonadIO m) => O.MethodInfo IndexEntriesResolveUndoGetMethodInfo IndexEntriesResolveUndo signature where + overloadedMethod _ = indexEntriesResolveUndoGet + +#endif + +-- method IndexEntriesResolveUndo::get_by_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntriesResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_resolve_undo_get_by_file" ggit_index_entries_resolve_undo_get_by_file :: + Ptr IndexEntriesResolveUndo -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + IO (Ptr Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo) + +{- | +Get an resolve_undo entry specified by path. The returned entry is read +only and should not be modified by the caller. If the entry could not be +found, 'Nothing' is returned. +-} +indexEntriesResolveUndoGetByFile :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + IndexEntriesResolveUndo + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo'. -} + -> a + {- ^ /@file@/: a 'GI.Gio.Interfaces.File.File'. -} + -> m (Maybe Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo' or 'Nothing'. -} +indexEntriesResolveUndoGetByFile entries file = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + file' <- unsafeManagedPtrCastPtr file + result <- ggit_index_entries_resolve_undo_get_by_file entries' file' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo) result' + return result'' + touchManagedPtr entries + touchManagedPtr file + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoGetByFileMethodInfo +instance (signature ~ (a -> m (Maybe Ggit.IndexEntryResolveUndo.IndexEntryResolveUndo)), MonadIO m, Gio.File.IsFile a) => O.MethodInfo IndexEntriesResolveUndoGetByFileMethodInfo IndexEntriesResolveUndo signature where + overloadedMethod _ = indexEntriesResolveUndoGetByFile + +#endif + +-- method IndexEntriesResolveUndo::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntriesResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_resolve_undo_ref" ggit_index_entries_resolve_undo_ref :: + Ptr IndexEntriesResolveUndo -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}) + IO (Ptr IndexEntriesResolveUndo) + +{- | +Atomically increments the reference count of /@entries@/ by one. +This function is MT-safe and may be called from any thread. +-} +indexEntriesResolveUndoRef :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntriesResolveUndo + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo'. -} + -> m (Maybe IndexEntriesResolveUndo) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo' or 'Nothing'. -} +indexEntriesResolveUndoRef entries = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + result <- ggit_index_entries_resolve_undo_ref entries' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed IndexEntriesResolveUndo) result' + return result'' + touchManagedPtr entries + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoRefMethodInfo +instance (signature ~ (m (Maybe IndexEntriesResolveUndo)), MonadIO m) => O.MethodInfo IndexEntriesResolveUndoRefMethodInfo IndexEntriesResolveUndo signature where + overloadedMethod _ = indexEntriesResolveUndoRef + +#endif + +-- method IndexEntriesResolveUndo::size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntriesResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_resolve_undo_size" ggit_index_entries_resolve_undo_size :: + Ptr IndexEntriesResolveUndo -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}) + IO Word32 + +{- | +Get the number of 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo' entries. +-} +indexEntriesResolveUndoSize :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntriesResolveUndo + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo'. -} + -> m Word32 + {- ^ __Returns:__ the number of entries. -} +indexEntriesResolveUndoSize entries = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + result <- ggit_index_entries_resolve_undo_size entries' + touchManagedPtr entries + return result + +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntriesResolveUndoSizeMethodInfo IndexEntriesResolveUndo signature where + overloadedMethod _ = indexEntriesResolveUndoSize + +#endif + +-- method IndexEntriesResolveUndo::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntriesResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entries_resolve_undo_unref" ggit_index_entries_resolve_undo_unref :: + Ptr IndexEntriesResolveUndo -> -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntriesResolveUndo"}) + IO () + +{- | +Atomically decrements the reference count of /@entries@/ by one. +If the reference count drops to 0, /@entries@/ is freed. +-} +indexEntriesResolveUndoUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntriesResolveUndo + {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo'. -} + -> m () +indexEntriesResolveUndoUnref entries = liftIO $ do + entries' <- unsafeManagedPtrGetPtr entries + ggit_index_entries_resolve_undo_unref entries' + touchManagedPtr entries + return () + +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IndexEntriesResolveUndoUnrefMethodInfo IndexEntriesResolveUndo signature where + overloadedMethod _ = indexEntriesResolveUndoUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveIndexEntriesResolveUndoMethod (t :: Symbol) (o :: *) :: * where + ResolveIndexEntriesResolveUndoMethod "get" o = IndexEntriesResolveUndoGetMethodInfo + ResolveIndexEntriesResolveUndoMethod "ref" o = IndexEntriesResolveUndoRefMethodInfo + ResolveIndexEntriesResolveUndoMethod "size" o = IndexEntriesResolveUndoSizeMethodInfo + ResolveIndexEntriesResolveUndoMethod "unref" o = IndexEntriesResolveUndoUnrefMethodInfo + ResolveIndexEntriesResolveUndoMethod "getByFile" o = IndexEntriesResolveUndoGetByFileMethodInfo + ResolveIndexEntriesResolveUndoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIndexEntriesResolveUndoMethod t IndexEntriesResolveUndo, O.MethodInfo info IndexEntriesResolveUndo p) => OL.IsLabel t (IndexEntriesResolveUndo -> 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 + + diff --git a/GI/Ggit/Structs/IndexEntriesResolveUndo.hs-boot b/GI/Ggit/Structs/IndexEntriesResolveUndo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntriesResolveUndo.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.IndexEntriesResolveUndo 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 + +newtype IndexEntriesResolveUndo = IndexEntriesResolveUndo (ManagedPtr IndexEntriesResolveUndo) +instance BoxedObject IndexEntriesResolveUndo where +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoGetMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoGetByFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntriesResolveUndoUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/IndexEntry.hs b/GI/Ggit/Structs/IndexEntry.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntry.hs @@ -0,0 +1,1215 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents an index entry object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.IndexEntry + ( + +-- * Exported types + IndexEntry(..) , + noIndexEntry , + + + -- * Methods +-- ** getDev #method:getDev# + +#if ENABLE_OVERLOADING + IndexEntryGetDevMethodInfo , +#endif + indexEntryGetDev , + + +-- ** getFileSize #method:getFileSize# + +#if ENABLE_OVERLOADING + IndexEntryGetFileSizeMethodInfo , +#endif + indexEntryGetFileSize , + + +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + IndexEntryGetFlagsMethodInfo , +#endif + indexEntryGetFlags , + + +-- ** getFlagsExtended #method:getFlagsExtended# + +#if ENABLE_OVERLOADING + IndexEntryGetFlagsExtendedMethodInfo , +#endif + indexEntryGetFlagsExtended , + + +-- ** getGid #method:getGid# + +#if ENABLE_OVERLOADING + IndexEntryGetGidMethodInfo , +#endif + indexEntryGetGid , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + IndexEntryGetIdMethodInfo , +#endif + indexEntryGetId , + + +-- ** getIno #method:getIno# + +#if ENABLE_OVERLOADING + IndexEntryGetInoMethodInfo , +#endif + indexEntryGetIno , + + +-- ** getMode #method:getMode# + +#if ENABLE_OVERLOADING + IndexEntryGetModeMethodInfo , +#endif + indexEntryGetMode , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + IndexEntryGetPathMethodInfo , +#endif + indexEntryGetPath , + + +-- ** getUid #method:getUid# + +#if ENABLE_OVERLOADING + IndexEntryGetUidMethodInfo , +#endif + indexEntryGetUid , + + +-- ** isConflict #method:isConflict# + +#if ENABLE_OVERLOADING + IndexEntryIsConflictMethodInfo , +#endif + indexEntryIsConflict , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + IndexEntryRefMethodInfo , +#endif + indexEntryRef , + + +-- ** setCommit #method:setCommit# + +#if ENABLE_OVERLOADING + IndexEntrySetCommitMethodInfo , +#endif + indexEntrySetCommit , + + +-- ** setDev #method:setDev# + +#if ENABLE_OVERLOADING + IndexEntrySetDevMethodInfo , +#endif + indexEntrySetDev , + + +-- ** setFileSize #method:setFileSize# + +#if ENABLE_OVERLOADING + IndexEntrySetFileSizeMethodInfo , +#endif + indexEntrySetFileSize , + + +-- ** setFlags #method:setFlags# + +#if ENABLE_OVERLOADING + IndexEntrySetFlagsMethodInfo , +#endif + indexEntrySetFlags , + + +-- ** setFlagsExtended #method:setFlagsExtended# + +#if ENABLE_OVERLOADING + IndexEntrySetFlagsExtendedMethodInfo , +#endif + indexEntrySetFlagsExtended , + + +-- ** setGid #method:setGid# + +#if ENABLE_OVERLOADING + IndexEntrySetGidMethodInfo , +#endif + indexEntrySetGid , + + +-- ** setId #method:setId# + +#if ENABLE_OVERLOADING + IndexEntrySetIdMethodInfo , +#endif + indexEntrySetId , + + +-- ** setIno #method:setIno# + +#if ENABLE_OVERLOADING + IndexEntrySetInoMethodInfo , +#endif + indexEntrySetIno , + + +-- ** setMode #method:setMode# + +#if ENABLE_OVERLOADING + IndexEntrySetModeMethodInfo , +#endif + indexEntrySetMode , + + +-- ** setPath #method:setPath# + +#if ENABLE_OVERLOADING + IndexEntrySetPathMethodInfo , +#endif + indexEntrySetPath , + + +-- ** setUid #method:setUid# + +#if ENABLE_OVERLOADING + IndexEntrySetUidMethodInfo , +#endif + indexEntrySetUid , + + +-- ** stat #method:stat# + +#if ENABLE_OVERLOADING + IndexEntryStatMethodInfo , +#endif + indexEntryStat , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + IndexEntryUnrefMethodInfo , +#endif + indexEntryUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.Commit as Ggit.Commit +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import qualified GI.Gio.Interfaces.File as Gio.File + +-- | Memory-managed wrapper type. +newtype IndexEntry = IndexEntry (ManagedPtr IndexEntry) +foreign import ccall "ggit_index_entry_get_type" c_ggit_index_entry_get_type :: + IO GType + +instance BoxedObject IndexEntry where + boxedType _ = c_ggit_index_entry_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `IndexEntry`. +noIndexEntry :: Maybe IndexEntry +noIndexEntry = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList IndexEntry +type instance O.AttributeList IndexEntry = IndexEntryAttributeList +type IndexEntryAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method IndexEntry::get_dev +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_dev" ggit_index_entry_get_dev :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Word32 + +{- | +Get the dev of the index entry. +-} +indexEntryGetDev :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Word32 + {- ^ __Returns:__ the dev. -} +indexEntryGetDev entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_dev entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetDevMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntryGetDevMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetDev + +#endif + +-- method IndexEntry::get_file_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_file_size" ggit_index_entry_get_file_size :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Int64 + +{- | +Get the file size of the index entry. +-} +indexEntryGetFileSize :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Int64 + {- ^ __Returns:__ the file size. -} +indexEntryGetFileSize entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_file_size entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetFileSizeMethodInfo +instance (signature ~ (m Int64), MonadIO m) => O.MethodInfo IndexEntryGetFileSizeMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetFileSize + +#endif + +-- method IndexEntry::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_flags" ggit_index_entry_get_flags :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Word32 + +{- | +Get the flags of the index entry. +-} +indexEntryGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Word32 + {- ^ __Returns:__ the flags. -} +indexEntryGetFlags entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_flags entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetFlagsMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntryGetFlagsMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetFlags + +#endif + +-- method IndexEntry::get_flags_extended +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_flags_extended" ggit_index_entry_get_flags_extended :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Word32 + +{- | +Get the extended flags of the index entry. +-} +indexEntryGetFlagsExtended :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Word32 + {- ^ __Returns:__ the extended flags. -} +indexEntryGetFlagsExtended entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_flags_extended entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetFlagsExtendedMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntryGetFlagsExtendedMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetFlagsExtended + +#endif + +-- method IndexEntry::get_gid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_gid" ggit_index_entry_get_gid :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Word32 + +{- | +Get the gid of the index entry. +-} +indexEntryGetGid :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Word32 + {- ^ __Returns:__ the gid. -} +indexEntryGetGid entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_gid entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetGidMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntryGetGidMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetGid + +#endif + +-- method IndexEntry::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_id" ggit_index_entry_get_id :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the oid of the index entry. +-} +indexEntryGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the oid or 'Nothing'. -} +indexEntryGetId entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_id entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntryGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo IndexEntryGetIdMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetId + +#endif + +-- method IndexEntry::get_ino +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_ino" ggit_index_entry_get_ino :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Word32 + +{- | +Get the ino of the index entry. +-} +indexEntryGetIno :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Word32 + {- ^ __Returns:__ the ino. -} +indexEntryGetIno entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_ino entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetInoMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntryGetInoMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetIno + +#endif + +-- method IndexEntry::get_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_mode" ggit_index_entry_get_mode :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Word32 + +{- | +Get the mode of the index entry. +-} +indexEntryGetMode :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Word32 + {- ^ __Returns:__ the mode. -} +indexEntryGetMode entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_mode entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetModeMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntryGetModeMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetMode + +#endif + +-- method IndexEntry::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_path" ggit_index_entry_get_path :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +indexEntryGetPath :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + -> m T.Text +indexEntryGetPath entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_path entry' + checkUnexpectedReturnNULL "indexEntryGetPath" result + result' <- cstringToText result + touchManagedPtr entry + return result' + +#if ENABLE_OVERLOADING +data IndexEntryGetPathMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo IndexEntryGetPathMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetPath + +#endif + +-- method IndexEntry::get_uid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_get_uid" ggit_index_entry_get_uid :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO Word32 + +{- | +Get the uid of the index entry. +-} +indexEntryGetUid :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Word32 + {- ^ __Returns:__ the uid. -} +indexEntryGetUid entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_get_uid entry' + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryGetUidMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntryGetUidMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryGetUid + +#endif + +-- method IndexEntry::is_conflict +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_is_conflict" ggit_index_entry_is_conflict :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO CInt + +{- | +Get whether the entry represents a conflict. +-} +indexEntryIsConflict :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the entry is a conflict, or 'False' otherwise. -} +indexEntryIsConflict entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_is_conflict entry' + let result' = (/= 0) result + touchManagedPtr entry + return result' + +#if ENABLE_OVERLOADING +data IndexEntryIsConflictMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo IndexEntryIsConflictMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryIsConflict + +#endif + +-- method IndexEntry::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_ref" ggit_index_entry_ref :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO (Ptr IndexEntry) + +{- | +Atomically increments the reference count of /@entry@/ by one. +This function is MT-safe and may be called from any thread. +-} +indexEntryRef :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m (Maybe IndexEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntry.IndexEntry' or 'Nothing'. -} +indexEntryRef entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_ref entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed IndexEntry) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntryRefMethodInfo +instance (signature ~ (m (Maybe IndexEntry)), MonadIO m) => O.MethodInfo IndexEntryRefMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryRef + +#endif + +-- method IndexEntry::set_commit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TInterface (Name {namespace = "Ggit", name = "Commit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitCommit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_commit" ggit_index_entry_set_commit :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Ptr Ggit.Commit.Commit -> -- commit : TInterface (Name {namespace = "Ggit", name = "Commit"}) + IO () + +{- | +Set the index entry to point to a given commit. This sets the index entry +id to the commit id, changes the mode to @/GGIT_FILE_MODE_COMMIT/@ and updates +the timestamps to when the commit was made. +-} +indexEntrySetCommit :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Commit.IsCommit a) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> a + {- ^ /@commit@/: a 'GI.Ggit.Objects.Commit.Commit'. -} + -> m () +indexEntrySetCommit entry commit = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + commit' <- unsafeManagedPtrCastPtr commit + ggit_index_entry_set_commit entry' commit' + touchManagedPtr entry + touchManagedPtr commit + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetCommitMethodInfo +instance (signature ~ (a -> m ()), MonadIO m, Ggit.Commit.IsCommit a) => O.MethodInfo IndexEntrySetCommitMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetCommit + +#endif + +-- method IndexEntry::set_dev +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dev", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the dev.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_dev" ggit_index_entry_set_dev :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Word32 -> -- dev : TBasicType TUInt + IO () + +{- | +Set the dev of the index entry. +-} +indexEntrySetDev :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Word32 + {- ^ /@dev@/: the dev. -} + -> m () +indexEntrySetDev entry dev = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_dev entry' dev + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetDevMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetDevMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetDev + +#endif + +-- method IndexEntry::set_file_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file size.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_file_size" ggit_index_entry_set_file_size :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Int64 -> -- file_size : TBasicType TInt64 + IO () + +{- | +Set the file size of the index entry. +-} +indexEntrySetFileSize :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Int64 + {- ^ /@fileSize@/: the file size. -} + -> m () +indexEntrySetFileSize entry fileSize = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_file_size entry' fileSize + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetFileSizeMethodInfo +instance (signature ~ (Int64 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetFileSizeMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetFileSize + +#endif + +-- method IndexEntry::set_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the flags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_flags" ggit_index_entry_set_flags :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Word32 -> -- flags : TBasicType TUInt + IO () + +{- | +Set the flags of the index entry. +-} +indexEntrySetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Word32 + {- ^ /@flags@/: the flags. -} + -> m () +indexEntrySetFlags entry flags = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_flags entry' flags + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetFlagsMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetFlagsMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetFlags + +#endif + +-- method IndexEntry::set_flags_extended +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags_extended", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the extended flags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_flags_extended" ggit_index_entry_set_flags_extended :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Word32 -> -- flags_extended : TBasicType TUInt + IO () + +{- | +Set the extended flags of the index entry. +-} +indexEntrySetFlagsExtended :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Word32 + {- ^ /@flagsExtended@/: the extended flags. -} + -> m () +indexEntrySetFlagsExtended entry flagsExtended = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_flags_extended entry' flagsExtended + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetFlagsExtendedMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetFlagsExtendedMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetFlagsExtended + +#endif + +-- method IndexEntry::set_gid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gid", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the gid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_gid" ggit_index_entry_set_gid :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Word32 -> -- gid : TBasicType TUInt + IO () + +{- | +Set the gid of the index entry. +-} +indexEntrySetGid :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Word32 + {- ^ /@gid@/: the gid. -} + -> m () +indexEntrySetGid entry gid = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_gid entry' gid + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetGidMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetGidMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetGid + +#endif + +-- method IndexEntry::set_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the oid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_id" ggit_index_entry_set_id :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Ptr Ggit.OId.OId -> -- id : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO () + +{- | +Set the oid of the index entry. +-} +indexEntrySetId :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Maybe (Ggit.OId.OId) + {- ^ /@id@/: the oid. -} + -> m () +indexEntrySetId entry id = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + maybeId <- case id of + Nothing -> return nullPtr + Just jId -> do + jId' <- unsafeManagedPtrGetPtr jId + return jId' + ggit_index_entry_set_id entry' maybeId + touchManagedPtr entry + whenJust id touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetIdMethodInfo +instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetIdMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetId + +#endif + +-- method IndexEntry::set_ino +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ino", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the ino.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_ino" ggit_index_entry_set_ino :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Word32 -> -- ino : TBasicType TUInt + IO () + +{- | +Set the ino of the index entry. +-} +indexEntrySetIno :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Word32 + {- ^ /@ino@/: the ino. -} + -> m () +indexEntrySetIno entry ino = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_ino entry' ino + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetInoMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetInoMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetIno + +#endif + +-- method IndexEntry::set_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the mode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_mode" ggit_index_entry_set_mode :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Word32 -> -- mode : TBasicType TUInt + IO () + +{- | +Set the mode of the index entry. +-} +indexEntrySetMode :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Word32 + {- ^ /@mode@/: the mode. -} + -> m () +indexEntrySetMode entry mode = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_mode entry' mode + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetModeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetModeMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetMode + +#endif + +-- method IndexEntry::set_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_path" ggit_index_entry_set_path :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + CString -> -- path : TBasicType TUTF8 + IO () + +{- | +Set the path of the index entry. The path should be relative to the working +directory. +-} +indexEntrySetPath :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Maybe (T.Text) + {- ^ /@path@/: the path. -} + -> m () +indexEntrySetPath entry path = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + maybePath <- case path of + Nothing -> return nullPtr + Just jPath -> do + jPath' <- textToCString jPath + return jPath' + ggit_index_entry_set_path entry' maybePath + touchManagedPtr entry + freeMem maybePath + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetPathMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetPathMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetPath + +#endif + +-- method IndexEntry::set_uid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uid", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the uid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_set_uid" ggit_index_entry_set_uid :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Word32 -> -- uid : TBasicType TUInt + IO () + +{- | +Set the uid of the index entry. +-} +indexEntrySetUid :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> Word32 + {- ^ /@uid@/: the uid. -} + -> m () +indexEntrySetUid entry uid = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_set_uid entry' uid + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntrySetUidMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo IndexEntrySetUidMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntrySetUid + +#endif + +-- method IndexEntry::stat +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file to stat.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_index_entry_stat" ggit_index_entry_stat :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Fill the entry fields from statting /@file@/. +-} +indexEntryStat :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> a + {- ^ /@file@/: the file to stat. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +indexEntryStat entry file = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + file' <- unsafeManagedPtrCastPtr file + onException (do + _ <- propagateGError $ ggit_index_entry_stat entry' file' + touchManagedPtr entry + touchManagedPtr file + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data IndexEntryStatMethodInfo +instance (signature ~ (a -> m ()), MonadIO m, Gio.File.IsFile a) => O.MethodInfo IndexEntryStatMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryStat + +#endif + +-- method IndexEntry::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_unref" ggit_index_entry_unref :: + Ptr IndexEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntry"}) + IO () + +{- | +Atomically decrements the reference count of /@entry@/ by one. +If the reference count drops to 0, /@entry@/ is freed. +-} +indexEntryUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntry.IndexEntry'. -} + -> m () +indexEntryUnref entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_unref entry' + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntryUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IndexEntryUnrefMethodInfo IndexEntry signature where + overloadedMethod _ = indexEntryUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveIndexEntryMethod (t :: Symbol) (o :: *) :: * where + ResolveIndexEntryMethod "isConflict" o = IndexEntryIsConflictMethodInfo + ResolveIndexEntryMethod "ref" o = IndexEntryRefMethodInfo + ResolveIndexEntryMethod "stat" o = IndexEntryStatMethodInfo + ResolveIndexEntryMethod "unref" o = IndexEntryUnrefMethodInfo + ResolveIndexEntryMethod "getDev" o = IndexEntryGetDevMethodInfo + ResolveIndexEntryMethod "getFileSize" o = IndexEntryGetFileSizeMethodInfo + ResolveIndexEntryMethod "getFlags" o = IndexEntryGetFlagsMethodInfo + ResolveIndexEntryMethod "getFlagsExtended" o = IndexEntryGetFlagsExtendedMethodInfo + ResolveIndexEntryMethod "getGid" o = IndexEntryGetGidMethodInfo + ResolveIndexEntryMethod "getId" o = IndexEntryGetIdMethodInfo + ResolveIndexEntryMethod "getIno" o = IndexEntryGetInoMethodInfo + ResolveIndexEntryMethod "getMode" o = IndexEntryGetModeMethodInfo + ResolveIndexEntryMethod "getPath" o = IndexEntryGetPathMethodInfo + ResolveIndexEntryMethod "getUid" o = IndexEntryGetUidMethodInfo + ResolveIndexEntryMethod "setCommit" o = IndexEntrySetCommitMethodInfo + ResolveIndexEntryMethod "setDev" o = IndexEntrySetDevMethodInfo + ResolveIndexEntryMethod "setFileSize" o = IndexEntrySetFileSizeMethodInfo + ResolveIndexEntryMethod "setFlags" o = IndexEntrySetFlagsMethodInfo + ResolveIndexEntryMethod "setFlagsExtended" o = IndexEntrySetFlagsExtendedMethodInfo + ResolveIndexEntryMethod "setGid" o = IndexEntrySetGidMethodInfo + ResolveIndexEntryMethod "setId" o = IndexEntrySetIdMethodInfo + ResolveIndexEntryMethod "setIno" o = IndexEntrySetInoMethodInfo + ResolveIndexEntryMethod "setMode" o = IndexEntrySetModeMethodInfo + ResolveIndexEntryMethod "setPath" o = IndexEntrySetPathMethodInfo + ResolveIndexEntryMethod "setUid" o = IndexEntrySetUidMethodInfo + ResolveIndexEntryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIndexEntryMethod t IndexEntry, O.MethodInfo info IndexEntry p) => OL.IsLabel t (IndexEntry -> 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 + + diff --git a/GI/Ggit/Structs/IndexEntry.hs-boot b/GI/Ggit/Structs/IndexEntry.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntry.hs-boot @@ -0,0 +1,101 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.IndexEntry 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 + +newtype IndexEntry = IndexEntry (ManagedPtr IndexEntry) +instance BoxedObject IndexEntry where +#if ENABLE_OVERLOADING +data IndexEntryGetDevMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetFileSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetFlagsExtendedMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetGidMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetInoMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryGetUidMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryIsConflictMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetCommitMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetDevMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetFileSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetFlagsExtendedMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetGidMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetInoMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntrySetUidMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryStatMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/IndexEntryResolveUndo.hs b/GI/Ggit/Structs/IndexEntryResolveUndo.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntryResolveUndo.hs @@ -0,0 +1,314 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents an resolve undo index entry object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.IndexEntryResolveUndo + ( + +-- * Exported types + IndexEntryResolveUndo(..) , + noIndexEntryResolveUndo , + + + -- * Methods +-- ** getFile #method:getFile# + +#if ENABLE_OVERLOADING + IndexEntryResolveUndoGetFileMethodInfo , +#endif + indexEntryResolveUndoGetFile , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + IndexEntryResolveUndoGetIdMethodInfo , +#endif + indexEntryResolveUndoGetId , + + +-- ** getMode #method:getMode# + +#if ENABLE_OVERLOADING + IndexEntryResolveUndoGetModeMethodInfo , +#endif + indexEntryResolveUndoGetMode , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + IndexEntryResolveUndoRefMethodInfo , +#endif + indexEntryResolveUndoRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + IndexEntryResolveUndoUnrefMethodInfo , +#endif + indexEntryResolveUndoUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import qualified GI.Gio.Interfaces.File as Gio.File + +-- | Memory-managed wrapper type. +newtype IndexEntryResolveUndo = IndexEntryResolveUndo (ManagedPtr IndexEntryResolveUndo) +foreign import ccall "ggit_index_entry_resolve_undo_get_type" c_ggit_index_entry_resolve_undo_get_type :: + IO GType + +instance BoxedObject IndexEntryResolveUndo where + boxedType _ = c_ggit_index_entry_resolve_undo_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `IndexEntryResolveUndo`. +noIndexEntryResolveUndo :: Maybe IndexEntryResolveUndo +noIndexEntryResolveUndo = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList IndexEntryResolveUndo +type instance O.AttributeList IndexEntryResolveUndo = IndexEntryResolveUndoAttributeList +type IndexEntryResolveUndoAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method IndexEntryResolveUndo::get_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntryResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_resolve_undo_get_file" ggit_index_entry_resolve_undo_get_file :: + Ptr IndexEntryResolveUndo -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}) + IO (Ptr Gio.File.File) + +{- | +Get the file of the index entry. +-} +indexEntryResolveUndoGetFile :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntryResolveUndo + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo'. -} + -> m (Maybe Gio.File.File) + {- ^ __Returns:__ a 'GI.Gio.Interfaces.File.File' or 'Nothing'. -} +indexEntryResolveUndoGetFile entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_resolve_undo_get_file entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Gio.File.File) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoGetFileMethodInfo +instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m) => O.MethodInfo IndexEntryResolveUndoGetFileMethodInfo IndexEntryResolveUndo signature where + overloadedMethod _ = indexEntryResolveUndoGetFile + +#endif + +-- method IndexEntryResolveUndo::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntryResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stage", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stage (0, 1 or 2).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_resolve_undo_get_id" ggit_index_entry_resolve_undo_get_id :: + Ptr IndexEntryResolveUndo -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}) + Int32 -> -- stage : TBasicType TInt + IO (Ptr Ggit.OId.OId) + +{- | +Get the oid of the index entry. +-} +indexEntryResolveUndoGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntryResolveUndo + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo'. -} + -> Int32 + {- ^ /@stage@/: the stage (0, 1 or 2). -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the oid or 'Nothing'. -} +indexEntryResolveUndoGetId entry stage = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_resolve_undo_get_id entry' stage + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoGetIdMethodInfo +instance (signature ~ (Int32 -> m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo IndexEntryResolveUndoGetIdMethodInfo IndexEntryResolveUndo signature where + overloadedMethod _ = indexEntryResolveUndoGetId + +#endif + +-- method IndexEntryResolveUndo::get_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntryResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stage", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stage (0, 1 or 2).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_resolve_undo_get_mode" ggit_index_entry_resolve_undo_get_mode :: + Ptr IndexEntryResolveUndo -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}) + Int32 -> -- stage : TBasicType TInt + IO Word32 + +{- | +Get the mode of the index entry. The returned mode contains the modes from +stage 1, 2 and 3. +-} +indexEntryResolveUndoGetMode :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntryResolveUndo + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo'. -} + -> Int32 + {- ^ /@stage@/: the stage (0, 1 or 2). -} + -> m Word32 + {- ^ __Returns:__ the mode. -} +indexEntryResolveUndoGetMode entry stage = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_resolve_undo_get_mode entry' stage + touchManagedPtr entry + return result + +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoGetModeMethodInfo +instance (signature ~ (Int32 -> m Word32), MonadIO m) => O.MethodInfo IndexEntryResolveUndoGetModeMethodInfo IndexEntryResolveUndo signature where + overloadedMethod _ = indexEntryResolveUndoGetMode + +#endif + +-- method IndexEntryResolveUndo::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntryResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_resolve_undo_ref" ggit_index_entry_resolve_undo_ref :: + Ptr IndexEntryResolveUndo -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}) + IO (Ptr IndexEntryResolveUndo) + +{- | +Atomically increments the reference count of /@entry@/ by one. +This function is MT-safe and may be called from any thread. +-} +indexEntryResolveUndoRef :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntryResolveUndo + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo'. -} + -> m (Maybe IndexEntryResolveUndo) + {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo' or 'Nothing'. -} +indexEntryResolveUndoRef entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_index_entry_resolve_undo_ref entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed IndexEntryResolveUndo) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoRefMethodInfo +instance (signature ~ (m (Maybe IndexEntryResolveUndo)), MonadIO m) => O.MethodInfo IndexEntryResolveUndoRefMethodInfo IndexEntryResolveUndo signature where + overloadedMethod _ = indexEntryResolveUndoRef + +#endif + +-- method IndexEntryResolveUndo::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntryResolveUndo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_index_entry_resolve_undo_unref" ggit_index_entry_resolve_undo_unref :: + Ptr IndexEntryResolveUndo -> -- entry : TInterface (Name {namespace = "Ggit", name = "IndexEntryResolveUndo"}) + IO () + +{- | +Atomically decrements the reference count of /@entry@/ by one. +If the reference count drops to 0, /@entry@/ is freed. +-} +indexEntryResolveUndoUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexEntryResolveUndo + {- ^ /@entry@/: a 'GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo'. -} + -> m () +indexEntryResolveUndoUnref entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_index_entry_resolve_undo_unref entry' + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IndexEntryResolveUndoUnrefMethodInfo IndexEntryResolveUndo signature where + overloadedMethod _ = indexEntryResolveUndoUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveIndexEntryResolveUndoMethod (t :: Symbol) (o :: *) :: * where + ResolveIndexEntryResolveUndoMethod "ref" o = IndexEntryResolveUndoRefMethodInfo + ResolveIndexEntryResolveUndoMethod "unref" o = IndexEntryResolveUndoUnrefMethodInfo + ResolveIndexEntryResolveUndoMethod "getFile" o = IndexEntryResolveUndoGetFileMethodInfo + ResolveIndexEntryResolveUndoMethod "getId" o = IndexEntryResolveUndoGetIdMethodInfo + ResolveIndexEntryResolveUndoMethod "getMode" o = IndexEntryResolveUndoGetModeMethodInfo + ResolveIndexEntryResolveUndoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIndexEntryResolveUndoMethod t IndexEntryResolveUndo, O.MethodInfo info IndexEntryResolveUndo p) => OL.IsLabel t (IndexEntryResolveUndo -> 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 + + diff --git a/GI/Ggit/Structs/IndexEntryResolveUndo.hs-boot b/GI/Ggit/Structs/IndexEntryResolveUndo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/IndexEntryResolveUndo.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.IndexEntryResolveUndo 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 + +newtype IndexEntryResolveUndo = IndexEntryResolveUndo (ManagedPtr IndexEntryResolveUndo) +instance BoxedObject IndexEntryResolveUndo where +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoGetFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoGetModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexEntryResolveUndoUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/MergeOptions.hs b/GI/Ggit/Structs/MergeOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/MergeOptions.hs @@ -0,0 +1,750 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when merging. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.MergeOptions + ( + +-- * Exported types + MergeOptions(..) , + noMergeOptions , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + MergeOptionsCopyMethodInfo , +#endif + mergeOptionsCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + MergeOptionsFreeMethodInfo , +#endif + mergeOptionsFree , + + +-- ** getFileFavor #method:getFileFavor# + +#if ENABLE_OVERLOADING + MergeOptionsGetFileFavorMethodInfo , +#endif + mergeOptionsGetFileFavor , + + +-- ** getFileFlags #method:getFileFlags# + +#if ENABLE_OVERLOADING + MergeOptionsGetFileFlagsMethodInfo , +#endif + mergeOptionsGetFileFlags , + + +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + MergeOptionsGetFlagsMethodInfo , +#endif + mergeOptionsGetFlags , + + +-- ** getRenameThreshold #method:getRenameThreshold# + +#if ENABLE_OVERLOADING + MergeOptionsGetRenameThresholdMethodInfo, +#endif + mergeOptionsGetRenameThreshold , + + +-- ** getSimilarityMetric #method:getSimilarityMetric# + +#if ENABLE_OVERLOADING + MergeOptionsGetSimilarityMetricMethodInfo, +#endif + mergeOptionsGetSimilarityMetric , + + +-- ** getTargetLimit #method:getTargetLimit# + +#if ENABLE_OVERLOADING + MergeOptionsGetTargetLimitMethodInfo , +#endif + mergeOptionsGetTargetLimit , + + +-- ** new #method:new# + + mergeOptionsNew , + + +-- ** setFileFavor #method:setFileFavor# + +#if ENABLE_OVERLOADING + MergeOptionsSetFileFavorMethodInfo , +#endif + mergeOptionsSetFileFavor , + + +-- ** setFileFlags #method:setFileFlags# + +#if ENABLE_OVERLOADING + MergeOptionsSetFileFlagsMethodInfo , +#endif + mergeOptionsSetFileFlags , + + +-- ** setFlags #method:setFlags# + +#if ENABLE_OVERLOADING + MergeOptionsSetFlagsMethodInfo , +#endif + mergeOptionsSetFlags , + + +-- ** setRenameThreshold #method:setRenameThreshold# + +#if ENABLE_OVERLOADING + MergeOptionsSetRenameThresholdMethodInfo, +#endif + mergeOptionsSetRenameThreshold , + + +-- ** setSimilarityMetric #method:setSimilarityMetric# + +#if ENABLE_OVERLOADING + MergeOptionsSetSimilarityMetricMethodInfo, +#endif + mergeOptionsSetSimilarityMetric , + + +-- ** setTargetLimit #method:setTargetLimit# + +#if ENABLE_OVERLOADING + MergeOptionsSetTargetLimitMethodInfo , +#endif + mergeOptionsSetTargetLimit , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffSimilarityMetric as Ggit.DiffSimilarityMetric + +-- | Memory-managed wrapper type. +newtype MergeOptions = MergeOptions (ManagedPtr MergeOptions) +foreign import ccall "ggit_merge_options_get_type" c_ggit_merge_options_get_type :: + IO GType + +instance BoxedObject MergeOptions where + boxedType _ = c_ggit_merge_options_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `MergeOptions`. +noMergeOptions :: Maybe MergeOptions +noMergeOptions = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList MergeOptions +type instance O.AttributeList MergeOptions = MergeOptionsAttributeList +type MergeOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method MergeOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "MergeOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_new" ggit_merge_options_new :: + IO (Ptr MergeOptions) + +{- | +Creates a new 'GI.Ggit.Structs.MergeOptions.MergeOptions'. +-} +mergeOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m MergeOptions + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} +mergeOptionsNew = liftIO $ do + result <- ggit_merge_options_new + checkUnexpectedReturnNULL "mergeOptionsNew" result + result' <- (wrapBoxed MergeOptions) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method MergeOptions::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "MergeOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_copy" ggit_merge_options_copy :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO (Ptr MergeOptions) + +{- | +Copies /@mergeOptions@/ into a newly allocated 'GI.Ggit.Structs.MergeOptions.MergeOptions'. +-} +mergeOptionsCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m (Maybe MergeOptions) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.MergeOptions.MergeOptions' or 'Nothing'. -} +mergeOptionsCopy mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + result <- ggit_merge_options_copy mergeOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed MergeOptions) result' + return result'' + touchManagedPtr mergeOptions + return maybeResult + +#if ENABLE_OVERLOADING +data MergeOptionsCopyMethodInfo +instance (signature ~ (m (Maybe MergeOptions)), MonadIO m) => O.MethodInfo MergeOptionsCopyMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsCopy + +#endif + +-- method MergeOptions::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_free" ggit_merge_options_free :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO () + +{- | +Frees /@mergeOptions@/. +-} +mergeOptionsFree :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m () +mergeOptionsFree mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + ggit_merge_options_free mergeOptions' + touchManagedPtr mergeOptions + return () + +#if ENABLE_OVERLOADING +data MergeOptionsFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MergeOptionsFreeMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsFree + +#endif + +-- method MergeOptions::get_file_favor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "MergeFileFavor"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_get_file_favor" ggit_merge_options_get_file_favor :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO CUInt + +{- | +Get flags for handling conflicting content. +-} +mergeOptionsGetFileFavor :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m Ggit.Enums.MergeFileFavor + {- ^ __Returns:__ the file favor. -} +mergeOptionsGetFileFavor mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + result <- ggit_merge_options_get_file_favor mergeOptions' + let result' = (toEnum . fromIntegral) result + touchManagedPtr mergeOptions + return result' + +#if ENABLE_OVERLOADING +data MergeOptionsGetFileFavorMethodInfo +instance (signature ~ (m Ggit.Enums.MergeFileFavor), MonadIO m) => O.MethodInfo MergeOptionsGetFileFavorMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsGetFileFavor + +#endif + +-- method MergeOptions::get_file_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "MergeFileFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_get_file_flags" ggit_merge_options_get_file_flags :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO CUInt + +{- | +Get file merging flags. +-} +mergeOptionsGetFileFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m [Ggit.Flags.MergeFileFlags] + {- ^ __Returns:__ the file merging flags. -} +mergeOptionsGetFileFlags mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + result <- ggit_merge_options_get_file_flags mergeOptions' + let result' = wordToGFlags result + touchManagedPtr mergeOptions + return result' + +#if ENABLE_OVERLOADING +data MergeOptionsGetFileFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.MergeFileFlags]), MonadIO m) => O.MethodInfo MergeOptionsGetFileFlagsMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsGetFileFlags + +#endif + +-- method MergeOptions::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "MergeFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_get_flags" ggit_merge_options_get_flags :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO CUInt + +{- | +Get the tree flags to use for merging. +-} +mergeOptionsGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m [Ggit.Flags.MergeFlags] + {- ^ __Returns:__ the flags. -} +mergeOptionsGetFlags mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + result <- ggit_merge_options_get_flags mergeOptions' + let result' = wordToGFlags result + touchManagedPtr mergeOptions + return result' + +#if ENABLE_OVERLOADING +data MergeOptionsGetFlagsMethodInfo +instance (signature ~ (m [Ggit.Flags.MergeFlags]), MonadIO m) => O.MethodInfo MergeOptionsGetFlagsMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsGetFlags + +#endif + +-- method MergeOptions::get_rename_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_get_rename_threshold" ggit_merge_options_get_rename_threshold :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO Word32 + +{- | +Get the rename threshold (defaults to 50). If @/GGIT_MERGE_TREE_FIND_RENAMES/@ +is enabled, added files will be compared with deleted files to +determine their similarity. Files that are more similar than the rename +threshold (percentage-wise) will be treated as a rename. +-} +mergeOptionsGetRenameThreshold :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m Word32 + {- ^ __Returns:__ the rename threshold. -} +mergeOptionsGetRenameThreshold mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + result <- ggit_merge_options_get_rename_threshold mergeOptions' + touchManagedPtr mergeOptions + return result + +#if ENABLE_OVERLOADING +data MergeOptionsGetRenameThresholdMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo MergeOptionsGetRenameThresholdMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsGetRenameThreshold + +#endif + +-- method MergeOptions::get_similarity_metric +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_get_similarity_metric" ggit_merge_options_get_similarity_metric :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO (Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric) + +{- | +Get the similarity metric. +-} +mergeOptionsGetSimilarityMetric :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric) + {- ^ __Returns:__ the similarity metric, or 'Nothing'. -} +mergeOptionsGetSimilarityMetric mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + result <- ggit_merge_options_get_similarity_metric mergeOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.DiffSimilarityMetric.DiffSimilarityMetric) result' + return result'' + touchManagedPtr mergeOptions + return maybeResult + +#if ENABLE_OVERLOADING +data MergeOptionsGetSimilarityMetricMethodInfo +instance (signature ~ (m (Maybe Ggit.DiffSimilarityMetric.DiffSimilarityMetric)), MonadIO m) => O.MethodInfo MergeOptionsGetSimilarityMetricMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsGetSimilarityMetric + +#endif + +-- method MergeOptions::get_target_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_get_target_limit" ggit_merge_options_get_target_limit :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + IO Word32 + +{- | +Get the maximum number of similarity sources to examine for renames (defaults to 200). +If the number of rename candidates (add \/ delete pairs) is greater than +this value, inexact rename detection is aborted. +-} +mergeOptionsGetTargetLimit :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> m Word32 + {- ^ __Returns:__ the target limit. -} +mergeOptionsGetTargetLimit mergeOptions = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + result <- ggit_merge_options_get_target_limit mergeOptions' + touchManagedPtr mergeOptions + return result + +#if ENABLE_OVERLOADING +data MergeOptionsGetTargetLimitMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo MergeOptionsGetTargetLimitMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsGetTargetLimit + +#endif + +-- method MergeOptions::set_file_favor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_favor", argType = TInterface (Name {namespace = "Ggit", name = "MergeFileFavor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file favor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_set_file_favor" ggit_merge_options_set_file_favor :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + CUInt -> -- file_favor : TInterface (Name {namespace = "Ggit", name = "MergeFileFavor"}) + IO () + +{- | +Set flags for handling conflicting content. +-} +mergeOptionsSetFileFavor :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> Ggit.Enums.MergeFileFavor + {- ^ /@fileFavor@/: the file favor. -} + -> m () +mergeOptionsSetFileFavor mergeOptions fileFavor = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + let fileFavor' = (fromIntegral . fromEnum) fileFavor + ggit_merge_options_set_file_favor mergeOptions' fileFavor' + touchManagedPtr mergeOptions + return () + +#if ENABLE_OVERLOADING +data MergeOptionsSetFileFavorMethodInfo +instance (signature ~ (Ggit.Enums.MergeFileFavor -> m ()), MonadIO m) => O.MethodInfo MergeOptionsSetFileFavorMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsSetFileFavor + +#endif + +-- method MergeOptions::set_file_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_flags", argType = TInterface (Name {namespace = "Ggit", name = "MergeFileFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the file flags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_set_file_flags" ggit_merge_options_set_file_flags :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + CUInt -> -- file_flags : TInterface (Name {namespace = "Ggit", name = "MergeFileFlags"}) + IO () + +{- | +Set file merging flags. +-} +mergeOptionsSetFileFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> [Ggit.Flags.MergeFileFlags] + {- ^ /@fileFlags@/: the file flags. -} + -> m () +mergeOptionsSetFileFlags mergeOptions fileFlags = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + let fileFlags' = gflagsToWord fileFlags + ggit_merge_options_set_file_flags mergeOptions' fileFlags' + touchManagedPtr mergeOptions + return () + +#if ENABLE_OVERLOADING +data MergeOptionsSetFileFlagsMethodInfo +instance (signature ~ ([Ggit.Flags.MergeFileFlags] -> m ()), MonadIO m) => O.MethodInfo MergeOptionsSetFileFlagsMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsSetFileFlags + +#endif + +-- method MergeOptions::set_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Ggit", name = "MergeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_set_flags" ggit_merge_options_set_flags :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + CUInt -> -- flags : TInterface (Name {namespace = "Ggit", name = "MergeFlags"}) + IO () + +{- | +/No description available in the introspection data./ +-} +mergeOptionsSetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + -> [Ggit.Flags.MergeFlags] + -> m () +mergeOptionsSetFlags mergeOptions flags = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + let flags' = gflagsToWord flags + ggit_merge_options_set_flags mergeOptions' flags' + touchManagedPtr mergeOptions + return () + +#if ENABLE_OVERLOADING +data MergeOptionsSetFlagsMethodInfo +instance (signature ~ ([Ggit.Flags.MergeFlags] -> m ()), MonadIO m) => O.MethodInfo MergeOptionsSetFlagsMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsSetFlags + +#endif + +-- method MergeOptions::set_rename_threshold +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rename_threshold", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "similarity to consider a file renamed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_set_rename_threshold" ggit_merge_options_set_rename_threshold :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + Word32 -> -- rename_threshold : TBasicType TUInt + IO () + +{- | +Set the rename threshold (defaults to 50). If @/GGIT_MERGE_TREE_FIND_RENAMES/@ +is enabled, added files will be compared with deleted files to +determine their similarity. Files that are more similar than the rename +threshold (percentage-wise) will be treated as a rename. +-} +mergeOptionsSetRenameThreshold :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> Word32 + {- ^ /@renameThreshold@/: similarity to consider a file renamed. -} + -> m () +mergeOptionsSetRenameThreshold mergeOptions renameThreshold = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + ggit_merge_options_set_rename_threshold mergeOptions' renameThreshold + touchManagedPtr mergeOptions + return () + +#if ENABLE_OVERLOADING +data MergeOptionsSetRenameThresholdMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo MergeOptionsSetRenameThresholdMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsSetRenameThreshold + +#endif + +-- method MergeOptions::set_similarity_metric +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "metric", argType = TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSimilarityMetric.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_set_similarity_metric" ggit_merge_options_set_similarity_metric :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + Ptr Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> -- metric : TInterface (Name {namespace = "Ggit", name = "DiffSimilarityMetric"}) + IO () + +{- | +Set the similarity metric, or 'Nothing' for the default similarity metric. +-} +mergeOptionsSetSimilarityMetric :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> Ggit.DiffSimilarityMetric.DiffSimilarityMetric + {- ^ /@metric@/: a @/GgitSimilarityMetric/@. -} + -> m () +mergeOptionsSetSimilarityMetric mergeOptions metric = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + metric' <- unsafeManagedPtrGetPtr metric + ggit_merge_options_set_similarity_metric mergeOptions' metric' + touchManagedPtr mergeOptions + touchManagedPtr metric + return () + +#if ENABLE_OVERLOADING +data MergeOptionsSetSimilarityMetricMethodInfo +instance (signature ~ (Ggit.DiffSimilarityMetric.DiffSimilarityMetric -> m ()), MonadIO m) => O.MethodInfo MergeOptionsSetSimilarityMetricMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsSetSimilarityMetric + +#endif + +-- method MergeOptions::set_target_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_limit", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "maximum similarity source to examine for renames.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_merge_options_set_target_limit" ggit_merge_options_set_target_limit :: + Ptr MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + Word32 -> -- target_limit : TBasicType TUInt + IO () + +{- | +Set the maximum number of similarity sources to examine for renames (defaults to 200). +If the number of rename candidates (add \/ delete pairs) is greater than +this value, inexact rename detection is aborted. +-} +mergeOptionsSetTargetLimit :: + (B.CallStack.HasCallStack, MonadIO m) => + MergeOptions + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> Word32 + {- ^ /@targetLimit@/: maximum similarity source to examine for renames. -} + -> m () +mergeOptionsSetTargetLimit mergeOptions targetLimit = liftIO $ do + mergeOptions' <- unsafeManagedPtrGetPtr mergeOptions + ggit_merge_options_set_target_limit mergeOptions' targetLimit + touchManagedPtr mergeOptions + return () + +#if ENABLE_OVERLOADING +data MergeOptionsSetTargetLimitMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo MergeOptionsSetTargetLimitMethodInfo MergeOptions signature where + overloadedMethod _ = mergeOptionsSetTargetLimit + +#endif + +#if ENABLE_OVERLOADING +type family ResolveMergeOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveMergeOptionsMethod "copy" o = MergeOptionsCopyMethodInfo + ResolveMergeOptionsMethod "free" o = MergeOptionsFreeMethodInfo + ResolveMergeOptionsMethod "getFileFavor" o = MergeOptionsGetFileFavorMethodInfo + ResolveMergeOptionsMethod "getFileFlags" o = MergeOptionsGetFileFlagsMethodInfo + ResolveMergeOptionsMethod "getFlags" o = MergeOptionsGetFlagsMethodInfo + ResolveMergeOptionsMethod "getRenameThreshold" o = MergeOptionsGetRenameThresholdMethodInfo + ResolveMergeOptionsMethod "getSimilarityMetric" o = MergeOptionsGetSimilarityMetricMethodInfo + ResolveMergeOptionsMethod "getTargetLimit" o = MergeOptionsGetTargetLimitMethodInfo + ResolveMergeOptionsMethod "setFileFavor" o = MergeOptionsSetFileFavorMethodInfo + ResolveMergeOptionsMethod "setFileFlags" o = MergeOptionsSetFileFlagsMethodInfo + ResolveMergeOptionsMethod "setFlags" o = MergeOptionsSetFlagsMethodInfo + ResolveMergeOptionsMethod "setRenameThreshold" o = MergeOptionsSetRenameThresholdMethodInfo + ResolveMergeOptionsMethod "setSimilarityMetric" o = MergeOptionsSetSimilarityMetricMethodInfo + ResolveMergeOptionsMethod "setTargetLimit" o = MergeOptionsSetTargetLimitMethodInfo + ResolveMergeOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMergeOptionsMethod t MergeOptions, O.MethodInfo info MergeOptions p) => OL.IsLabel t (MergeOptions -> 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 + + diff --git a/GI/Ggit/Structs/MergeOptions.hs-boot b/GI/Ggit/Structs/MergeOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/MergeOptions.hs-boot @@ -0,0 +1,68 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.MergeOptions 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 + +newtype MergeOptions = MergeOptions (ManagedPtr MergeOptions) +instance BoxedObject MergeOptions where +#if ENABLE_OVERLOADING +data MergeOptionsCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsGetFileFavorMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsGetFileFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsGetRenameThresholdMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsGetSimilarityMetricMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsGetTargetLimitMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsSetFileFavorMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsSetFileFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsSetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsSetRenameThresholdMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsSetSimilarityMetricMethodInfo +#endif +#if ENABLE_OVERLOADING +data MergeOptionsSetTargetLimitMethodInfo +#endif diff --git a/GI/Ggit/Structs/Note.hs b/GI/Ggit/Structs/Note.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Note.hs @@ -0,0 +1,263 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a note object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.Note + ( + +-- * Exported types + Note(..) , + noNote , + + + -- * Methods +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + NoteGetIdMethodInfo , +#endif + noteGetId , + + +-- ** getMessage #method:getMessage# + +#if ENABLE_OVERLOADING + NoteGetMessageMethodInfo , +#endif + noteGetMessage , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + NoteRefMethodInfo , +#endif + noteRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + NoteUnrefMethodInfo , +#endif + noteUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype Note = Note (ManagedPtr Note) +foreign import ccall "ggit_note_get_type" c_ggit_note_get_type :: + IO GType + +instance BoxedObject Note where + boxedType _ = c_ggit_note_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Note`. +noNote :: Maybe Note +noNote = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Note +type instance O.AttributeList Note = NoteAttributeList +type NoteAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Note::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "note", argType = TInterface (Name {namespace = "Ggit", name = "Note"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitNote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_note_get_id" ggit_note_get_id :: + Ptr Note -> -- note : TInterface (Name {namespace = "Ggit", name = "Note"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the note object\'s id. +-} +noteGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + Note + {- ^ /@note@/: a 'GI.Ggit.Structs.Note.Note'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the object\'s id or 'Nothing'. -} +noteGetId note = liftIO $ do + note' <- unsafeManagedPtrGetPtr note + result <- ggit_note_get_id note' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr note + return maybeResult + +#if ENABLE_OVERLOADING +data NoteGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo NoteGetIdMethodInfo Note signature where + overloadedMethod _ = noteGetId + +#endif + +-- method Note::get_message +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "note", argType = TInterface (Name {namespace = "Ggit", name = "Note"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitNote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_note_get_message" ggit_note_get_message :: + Ptr Note -> -- note : TInterface (Name {namespace = "Ggit", name = "Note"}) + IO CString + +{- | +Gets the note message. +-} +noteGetMessage :: + (B.CallStack.HasCallStack, MonadIO m) => + Note + {- ^ /@note@/: a 'GI.Ggit.Structs.Note.Note'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the note message or 'Nothing'. -} +noteGetMessage note = liftIO $ do + note' <- unsafeManagedPtrGetPtr note + result <- ggit_note_get_message note' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr note + return maybeResult + +#if ENABLE_OVERLOADING +data NoteGetMessageMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo NoteGetMessageMethodInfo Note signature where + overloadedMethod _ = noteGetMessage + +#endif + +-- method Note::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "note", argType = TInterface (Name {namespace = "Ggit", name = "Note"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitNote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Note"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_note_ref" ggit_note_ref :: + Ptr Note -> -- note : TInterface (Name {namespace = "Ggit", name = "Note"}) + IO (Ptr Note) + +{- | +Atomically increments the reference count of /@note@/ by one. +This function is MT-safe and may be called from any thread. +-} +noteRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Note + {- ^ /@note@/: a 'GI.Ggit.Structs.Note.Note'. -} + -> m (Maybe Note) + {- ^ __Returns:__ a 'GI.Ggit.Structs.Note.Note' or 'Nothing'. -} +noteRef note = liftIO $ do + note' <- unsafeManagedPtrGetPtr note + result <- ggit_note_ref note' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Note) result' + return result'' + touchManagedPtr note + return maybeResult + +#if ENABLE_OVERLOADING +data NoteRefMethodInfo +instance (signature ~ (m (Maybe Note)), MonadIO m) => O.MethodInfo NoteRefMethodInfo Note signature where + overloadedMethod _ = noteRef + +#endif + +-- method Note::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "note", argType = TInterface (Name {namespace = "Ggit", name = "Note"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitNote.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_note_unref" ggit_note_unref :: + Ptr Note -> -- note : TInterface (Name {namespace = "Ggit", name = "Note"}) + IO () + +{- | +Atomically decrements the reference count of /@note@/ by one. +If the reference count drops to 0, /@note@/ is freed. +-} +noteUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Note + {- ^ /@note@/: a 'GI.Ggit.Structs.Note.Note'. -} + -> m () +noteUnref note = liftIO $ do + note' <- unsafeManagedPtrGetPtr note + ggit_note_unref note' + touchManagedPtr note + return () + +#if ENABLE_OVERLOADING +data NoteUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NoteUnrefMethodInfo Note signature where + overloadedMethod _ = noteUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveNoteMethod (t :: Symbol) (o :: *) :: * where + ResolveNoteMethod "ref" o = NoteRefMethodInfo + ResolveNoteMethod "unref" o = NoteUnrefMethodInfo + ResolveNoteMethod "getId" o = NoteGetIdMethodInfo + ResolveNoteMethod "getMessage" o = NoteGetMessageMethodInfo + ResolveNoteMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNoteMethod t Note, O.MethodInfo info Note p) => OL.IsLabel t (Note -> 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 + + diff --git a/GI/Ggit/Structs/Note.hs-boot b/GI/Ggit/Structs/Note.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Note.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.Note 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 + +newtype Note = Note (ManagedPtr Note) +instance BoxedObject Note where +#if ENABLE_OVERLOADING +data NoteGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data NoteGetMessageMethodInfo +#endif +#if ENABLE_OVERLOADING +data NoteRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data NoteUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/OId.hs b/GI/Ggit/Structs/OId.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/OId.hs @@ -0,0 +1,525 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a unique ID of any object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.OId + ( + +-- * Exported types + OId(..) , + noOId , + + + -- * Methods +-- ** compare #method:compare# + +#if ENABLE_OVERLOADING + OIdCompareMethodInfo , +#endif + oIdCompare , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + OIdCopyMethodInfo , +#endif + oIdCopy , + + +-- ** equal #method:equal# + +#if ENABLE_OVERLOADING + OIdEqualMethodInfo , +#endif + oIdEqual , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + OIdFreeMethodInfo , +#endif + oIdFree , + + +-- ** hasPrefix #method:hasPrefix# + +#if ENABLE_OVERLOADING + OIdHasPrefixMethodInfo , +#endif + oIdHasPrefix , + + +-- ** hash #method:hash# + +#if ENABLE_OVERLOADING + OIdHashMethodInfo , +#endif + oIdHash , + + +-- ** isZero #method:isZero# + +#if ENABLE_OVERLOADING + OIdIsZeroMethodInfo , +#endif + oIdIsZero , + + +-- ** newFromRaw #method:newFromRaw# + + oIdNewFromRaw , + + +-- ** newFromString #method:newFromString# + + oIdNewFromString , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + OIdToStringMethodInfo , +#endif + oIdToString , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype OId = OId (ManagedPtr OId) +foreign import ccall "ggit_oid_get_type" c_ggit_oid_get_type :: + IO GType + +instance BoxedObject OId where + boxedType _ = c_ggit_oid_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `OId`. +noOId :: Maybe OId +noOId = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList OId +type instance O.AttributeList OId = OIdAttributeList +type OIdAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method OId::new_from_raw +-- method type : Constructor +-- Args : [Arg {argCName = "raw", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the raw input bytes to be copied.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_new_from_raw" ggit_oid_new_from_raw :: + Word8 -> -- raw : TBasicType TUInt8 + IO (Ptr OId) + +{- | +Creates a new 'GI.Ggit.Structs.OId.OId' from a raw oid. +-} +oIdNewFromRaw :: + (B.CallStack.HasCallStack, MonadIO m) => + Word8 + {- ^ /@raw@/: the raw input bytes to be copied. -} + -> m (Maybe OId) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.OId.OId' or 'Nothing' on error. -} +oIdNewFromRaw raw = liftIO $ do + result <- ggit_oid_new_from_raw raw + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed OId) result' + return result'' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method OId::new_from_string +-- method type : Constructor +-- Args : [Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input hex string; must be pointing at the start of\n the hex sequence and have at least the number of bytes\n needed for an oid encoded in hex (40 bytes).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_new_from_string" ggit_oid_new_from_string :: + CString -> -- str : TBasicType TUTF8 + IO (Ptr OId) + +{- | +Parses a hex formatted object id into a 'GI.Ggit.Structs.OId.OId'. +-} +oIdNewFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@str@/: input hex string; must be pointing at the start of + the hex sequence and have at least the number of bytes + needed for an oid encoded in hex (40 bytes). -} + -> m (Maybe OId) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.OId.OId' or 'Nothing' on error. -} +oIdNewFromString str = liftIO $ do + str' <- textToCString str + result <- ggit_oid_new_from_string str' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed OId) result' + return result'' + freeMem str' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method OId::compare +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "a", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "first #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "second #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_compare" ggit_oid_compare :: + Ptr OId -> -- a : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr OId -> -- b : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO Int32 + +{- | +Compare two 'GI.Ggit.Structs.OId.OId' structures. +-} +oIdCompare :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@a@/: first 'GI.Ggit.Structs.OId.OId'. -} + -> OId + {- ^ /@b@/: second 'GI.Ggit.Structs.OId.OId'. -} + -> m Int32 + {- ^ __Returns:__ \<0, 0, >0 if a \< b, a == b, a > b. -} +oIdCompare a b = liftIO $ do + a' <- unsafeManagedPtrGetPtr a + b' <- unsafeManagedPtrGetPtr b + result <- ggit_oid_compare a' b' + touchManagedPtr a + touchManagedPtr b + return result + +#if ENABLE_OVERLOADING +data OIdCompareMethodInfo +instance (signature ~ (OId -> m Int32), MonadIO m) => O.MethodInfo OIdCompareMethodInfo OId signature where + overloadedMethod _ = oIdCompare + +#endif + +-- method OId::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_copy" ggit_oid_copy :: + Ptr OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO (Ptr OId) + +{- | +Copies /@oid@/ into a newly allocated 'GI.Ggit.Structs.OId.OId'. +-} +oIdCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe OId) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.OId.OId'. -} +oIdCopy oid = liftIO $ do + oid' <- unsafeManagedPtrGetPtr oid + result <- ggit_oid_copy oid' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed OId) result' + return result'' + touchManagedPtr oid + return maybeResult + +#if ENABLE_OVERLOADING +data OIdCopyMethodInfo +instance (signature ~ (m (Maybe OId)), MonadIO m) => O.MethodInfo OIdCopyMethodInfo OId signature where + overloadedMethod _ = oIdCopy + +#endif + +-- method OId::equal +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "a", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_equal" ggit_oid_equal :: + Ptr OId -> -- a : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr OId -> -- b : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO CInt + +{- | +Compares two 'GI.Ggit.Structs.OId.OId' for equality. +-} +oIdEqual :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@a@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> OId + {- ^ /@b@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m Bool + {- ^ __Returns:__ 'True' if /@a@/ and /@b@/ are equal, 'False' otherwise -} +oIdEqual a b = liftIO $ do + a' <- unsafeManagedPtrGetPtr a + b' <- unsafeManagedPtrGetPtr b + result <- ggit_oid_equal a' b' + let result' = (/= 0) result + touchManagedPtr a + touchManagedPtr b + return result' + +#if ENABLE_OVERLOADING +data OIdEqualMethodInfo +instance (signature ~ (OId -> m Bool), MonadIO m) => O.MethodInfo OIdEqualMethodInfo OId signature where + overloadedMethod _ = oIdEqual + +#endif + +-- method OId::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_free" ggit_oid_free :: + Ptr OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO () + +{- | +Frees /@oid@/. +-} +oIdFree :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m () +oIdFree oid = liftIO $ do + oid' <- unsafeManagedPtrGetPtr oid + ggit_oid_free oid' + touchManagedPtr oid + return () + +#if ENABLE_OVERLOADING +data OIdFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo OIdFreeMethodInfo OId signature where + overloadedMethod _ = oIdFree + +#endif + +-- method OId::has_prefix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prefix", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a prefix.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_has_prefix" ggit_oid_has_prefix :: + Ptr OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + CString -> -- prefix : TBasicType TUTF8 + IO CInt + +{- | +Check whether the object id has a given prefix. Note that the prefix is +specified in hexadecimal ASCII. +-} +oIdHasPrefix :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> T.Text + {- ^ /@prefix@/: a prefix. -} + -> m Bool + {- ^ __Returns:__ 'True' if the id has the given prefix, 'False' otherwise. -} +oIdHasPrefix oid prefix = liftIO $ do + oid' <- unsafeManagedPtrGetPtr oid + prefix' <- textToCString prefix + result <- ggit_oid_has_prefix oid' prefix' + let result' = (/= 0) result + touchManagedPtr oid + freeMem prefix' + return result' + +#if ENABLE_OVERLOADING +data OIdHasPrefixMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo OIdHasPrefixMethodInfo OId signature where + overloadedMethod _ = oIdHasPrefix + +#endif + +-- method OId::hash +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_hash" ggit_oid_hash :: + Ptr OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO Word32 + +{- | +Computes a hash value for a git object identifier. +-} +oIdHash :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m Word32 + {- ^ __Returns:__ the hash value -} +oIdHash oid = liftIO $ do + oid' <- unsafeManagedPtrGetPtr oid + result <- ggit_oid_hash oid' + touchManagedPtr oid + return result + +#if ENABLE_OVERLOADING +data OIdHashMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo OIdHashMethodInfo OId signature where + overloadedMethod _ = oIdHash + +#endif + +-- method OId::is_zero +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_is_zero" ggit_oid_is_zero :: + Ptr OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO CInt + +{- | +Get whether the oid contains only zeros. +-} +oIdIsZero :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the oid contains only zeros, 'False' otherwise. -} +oIdIsZero oid = liftIO $ do + oid' <- unsafeManagedPtrGetPtr oid + result <- ggit_oid_is_zero oid' + let result' = (/= 0) result + touchManagedPtr oid + return result' + +#if ENABLE_OVERLOADING +data OIdIsZeroMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo OIdIsZeroMethodInfo OId signature where + overloadedMethod _ = oIdIsZero + +#endif + +-- method OId::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_oid_to_string" ggit_oid_to_string :: + Ptr OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + IO CString + +{- | +Converts /@oid@/ into a readable string. +-} +oIdToString :: + (B.CallStack.HasCallStack, MonadIO m) => + OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ a newly allocated string representing /@oid@/ or 'Nothing'. -} +oIdToString oid = liftIO $ do + oid' <- unsafeManagedPtrGetPtr oid + result <- ggit_oid_to_string oid' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr oid + return maybeResult + +#if ENABLE_OVERLOADING +data OIdToStringMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo OIdToStringMethodInfo OId signature where + overloadedMethod _ = oIdToString + +#endif + +#if ENABLE_OVERLOADING +type family ResolveOIdMethod (t :: Symbol) (o :: *) :: * where + ResolveOIdMethod "compare" o = OIdCompareMethodInfo + ResolveOIdMethod "copy" o = OIdCopyMethodInfo + ResolveOIdMethod "equal" o = OIdEqualMethodInfo + ResolveOIdMethod "free" o = OIdFreeMethodInfo + ResolveOIdMethod "hasPrefix" o = OIdHasPrefixMethodInfo + ResolveOIdMethod "hash" o = OIdHashMethodInfo + ResolveOIdMethod "isZero" o = OIdIsZeroMethodInfo + ResolveOIdMethod "toString" o = OIdToStringMethodInfo + ResolveOIdMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveOIdMethod t OId, O.MethodInfo info OId p) => OL.IsLabel t (OId -> 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 + + diff --git a/GI/Ggit/Structs/OId.hs-boot b/GI/Ggit/Structs/OId.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/OId.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.OId 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 + +newtype OId = OId (ManagedPtr OId) +instance BoxedObject OId where +#if ENABLE_OVERLOADING +data OIdCompareMethodInfo +#endif +#if ENABLE_OVERLOADING +data OIdCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data OIdEqualMethodInfo +#endif +#if ENABLE_OVERLOADING +data OIdFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data OIdHasPrefixMethodInfo +#endif +#if ENABLE_OVERLOADING +data OIdHashMethodInfo +#endif +#if ENABLE_OVERLOADING +data OIdIsZeroMethodInfo +#endif +#if ENABLE_OVERLOADING +data OIdToStringMethodInfo +#endif diff --git a/GI/Ggit/Structs/Patch.hs b/GI/Ggit/Structs/Patch.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Patch.hs @@ -0,0 +1,670 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a patch object. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.Patch + ( + +-- * Exported types + Patch(..) , + noPatch , + + + -- * Methods +-- ** getDelta #method:getDelta# + +#if ENABLE_OVERLOADING + PatchGetDeltaMethodInfo , +#endif + patchGetDelta , + + +-- ** getHunk #method:getHunk# + +#if ENABLE_OVERLOADING + PatchGetHunkMethodInfo , +#endif + patchGetHunk , + + +-- ** getLineStats #method:getLineStats# + +#if ENABLE_OVERLOADING + PatchGetLineStatsMethodInfo , +#endif + patchGetLineStats , + + +-- ** getNumHunks #method:getNumHunks# + +#if ENABLE_OVERLOADING + PatchGetNumHunksMethodInfo , +#endif + patchGetNumHunks , + + +-- ** getNumLinesInHunk #method:getNumLinesInHunk# + +#if ENABLE_OVERLOADING + PatchGetNumLinesInHunkMethodInfo , +#endif + patchGetNumLinesInHunk , + + +-- ** newFromBlobs #method:newFromBlobs# + + patchNewFromBlobs , + + +-- ** newFromDiff #method:newFromDiff# + + patchNewFromDiff , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + PatchRefMethodInfo , +#endif + patchRef , + + +-- ** toStream #method:toStream# + +#if ENABLE_OVERLOADING + PatchToStreamMethodInfo , +#endif + patchToStream , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + PatchToStringMethodInfo , +#endif + patchToString , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + PatchUnrefMethodInfo , +#endif + patchUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.Blob as Ggit.Blob +import {-# SOURCE #-} qualified GI.Ggit.Objects.Diff as Ggit.Diff +import {-# SOURCE #-} qualified GI.Ggit.Objects.DiffOptions as Ggit.DiffOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffDelta as Ggit.DiffDelta +import {-# SOURCE #-} qualified GI.Ggit.Structs.DiffHunk as Ggit.DiffHunk +import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream + +-- | Memory-managed wrapper type. +newtype Patch = Patch (ManagedPtr Patch) +foreign import ccall "ggit_patch_get_type" c_ggit_patch_get_type :: + IO GType + +instance BoxedObject Patch where + boxedType _ = c_ggit_patch_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Patch`. +noPatch :: Maybe Patch +noPatch = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Patch +type instance O.AttributeList Patch = PatchAttributeList +type PatchAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Patch::new_from_blobs +-- method type : Constructor +-- Args : [Arg {argCName = "old_blob", argType = TInterface (Name {namespace = "Ggit", name = "Blob"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitBlob to diff from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_as_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "treat @old_blob as if it had this filename, or %NULL,", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_blob", argType = TInterface (Name {namespace = "Ggit", name = "Blob"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitBlob to diff to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_as_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "treat @new_blob as if it had this filename, or %NULL,", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff_options", argType = TInterface (Name {namespace = "Ggit", name = "DiffOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitDiffOptions, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Patch"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_patch_new_from_blobs" ggit_patch_new_from_blobs :: + Ptr Ggit.Blob.Blob -> -- old_blob : TInterface (Name {namespace = "Ggit", name = "Blob"}) + CString -> -- old_as_path : TBasicType TUTF8 + Ptr Ggit.Blob.Blob -> -- new_blob : TInterface (Name {namespace = "Ggit", name = "Blob"}) + CString -> -- new_as_path : TBasicType TUTF8 + Ptr Ggit.DiffOptions.DiffOptions -> -- diff_options : TInterface (Name {namespace = "Ggit", name = "DiffOptions"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Patch) + +{- | +Directly generate a patch from the difference between two blobs. + +This is just like 'GI.Ggit.Objects.Diff.diffBlobs' except it generates a patch object +for the difference instead of directly making callbacks. You can use the +standard ggit_patch accessor functions to read the patch data, and +you must call ggit_patch_unref on the patch when done. +-} +patchNewFromBlobs :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Blob.IsBlob a, Ggit.Blob.IsBlob b, Ggit.DiffOptions.IsDiffOptions c) => + Maybe (a) + {- ^ /@oldBlob@/: a 'GI.Ggit.Objects.Blob.Blob' to diff from. -} + -> Maybe (T.Text) + {- ^ /@oldAsPath@/: treat /@oldBlob@/ as if it had this filename, or 'Nothing', -} + -> Maybe (b) + {- ^ /@newBlob@/: a 'GI.Ggit.Objects.Blob.Blob' to diff to. -} + -> Maybe (T.Text) + {- ^ /@newAsPath@/: treat /@newBlob@/ as if it had this filename, or 'Nothing', -} + -> Maybe (c) + {- ^ /@diffOptions@/: a 'GI.Ggit.Objects.DiffOptions.DiffOptions', or 'Nothing'. -} + -> m (Maybe Patch) + {- ^ __Returns:__ a newly created 'GI.Ggit.Structs.Patch.Patch' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +patchNewFromBlobs oldBlob oldAsPath newBlob newAsPath diffOptions = liftIO $ do + maybeOldBlob <- case oldBlob of + Nothing -> return nullPtr + Just jOldBlob -> do + jOldBlob' <- unsafeManagedPtrCastPtr jOldBlob + return jOldBlob' + maybeOldAsPath <- case oldAsPath of + Nothing -> return nullPtr + Just jOldAsPath -> do + jOldAsPath' <- textToCString jOldAsPath + return jOldAsPath' + maybeNewBlob <- case newBlob of + Nothing -> return nullPtr + Just jNewBlob -> do + jNewBlob' <- unsafeManagedPtrCastPtr jNewBlob + return jNewBlob' + maybeNewAsPath <- case newAsPath of + Nothing -> return nullPtr + Just jNewAsPath -> do + jNewAsPath' <- textToCString jNewAsPath + return jNewAsPath' + maybeDiffOptions <- case diffOptions of + Nothing -> return nullPtr + Just jDiffOptions -> do + jDiffOptions' <- unsafeManagedPtrCastPtr jDiffOptions + return jDiffOptions' + onException (do + result <- propagateGError $ ggit_patch_new_from_blobs maybeOldBlob maybeOldAsPath maybeNewBlob maybeNewAsPath maybeDiffOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Patch) result' + return result'' + whenJust oldBlob touchManagedPtr + whenJust newBlob touchManagedPtr + whenJust diffOptions touchManagedPtr + freeMem maybeOldAsPath + freeMem maybeNewAsPath + return maybeResult + ) (do + freeMem maybeOldAsPath + freeMem maybeNewAsPath + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Patch::new_from_diff +-- method type : Constructor +-- Args : [Arg {argCName = "diff", argType = TInterface (Name {namespace = "Ggit", name = "Diff"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitDiff.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index into diff list.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Patch"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_patch_new_from_diff" ggit_patch_new_from_diff :: + Ptr Ggit.Diff.Diff -> -- diff : TInterface (Name {namespace = "Ggit", name = "Diff"}) + Word64 -> -- idx : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO (Ptr Patch) + +{- | +The 'GI.Ggit.Structs.Patch.Patch' is a newly created object contains the text diffs +for the delta. You have to call 'GI.Ggit.Structs.Patch.patchUnref' when you are +done with it. You can use the patch object to loop over all the hunks +and lines in the diff of the one delta. +-} +patchNewFromDiff :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Diff.IsDiff a) => + a + {- ^ /@diff@/: a 'GI.Ggit.Objects.Diff.Diff'. -} + -> Word64 + {- ^ /@idx@/: index into diff list. -} + -> m (Maybe Patch) + {- ^ __Returns:__ a newly created 'GI.Ggit.Structs.Patch.Patch' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +patchNewFromDiff diff idx = liftIO $ do + diff' <- unsafeManagedPtrCastPtr diff + onException (do + result <- propagateGError $ ggit_patch_new_from_diff diff' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Patch) result' + return result'' + touchManagedPtr diff + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Patch::get_delta +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffDelta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_patch_get_delta" ggit_patch_get_delta :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + IO (Ptr Ggit.DiffDelta.DiffDelta) + +{- | +Get the diff delta corresponding to the patch. +-} +patchGetDelta :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> m (Maybe Ggit.DiffDelta.DiffDelta) + {- ^ __Returns:__ the 'GI.Ggit.Structs.DiffDelta.DiffDelta' of the patch or 'Nothing'. -} +patchGetDelta patch = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + result <- ggit_patch_get_delta patch' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.DiffDelta.DiffDelta) result' + return result'' + touchManagedPtr patch + return maybeResult + +#if ENABLE_OVERLOADING +data PatchGetDeltaMethodInfo +instance (signature ~ (m (Maybe Ggit.DiffDelta.DiffDelta)), MonadIO m) => O.MethodInfo PatchGetDeltaMethodInfo Patch signature where + overloadedMethod _ = patchGetDelta + +#endif + +-- method Patch::get_hunk +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hunk index.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "DiffHunk"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_patch_get_hunk" ggit_patch_get_hunk :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + Word64 -> -- idx : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.DiffHunk.DiffHunk) + +{- | +Get the /@idx@/\'th hunk in the patch. +-} +patchGetHunk :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch' -} + -> Word64 + {- ^ /@idx@/: the hunk index. -} + -> m (Maybe Ggit.DiffHunk.DiffHunk) + {- ^ __Returns:__ a new 'GI.Ggit.Structs.DiffHunk.DiffHunk' or 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +patchGetHunk patch idx = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + onException (do + result <- propagateGError $ ggit_patch_get_hunk patch' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.DiffHunk.DiffHunk) result' + return result'' + touchManagedPtr patch + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data PatchGetHunkMethodInfo +instance (signature ~ (Word64 -> m (Maybe Ggit.DiffHunk.DiffHunk)), MonadIO m) => O.MethodInfo PatchGetHunkMethodInfo Patch signature where + overloadedMethod _ = patchGetHunk + +#endif + +-- method Patch::get_line_stats +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "total_context", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the number of context lines.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "total_additions", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the number of added lines.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "total_deletions", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the number of deleted lines.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_patch_get_line_stats" ggit_patch_get_line_stats :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + Ptr Word64 -> -- total_context : TBasicType TUInt64 + Ptr Word64 -> -- total_additions : TBasicType TUInt64 + Ptr Word64 -> -- total_deletions : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Get the line statistics of the patch. +-} +patchGetLineStats :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> m ((Word64, Word64, Word64)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +patchGetLineStats patch = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + totalContext <- allocMem :: IO (Ptr Word64) + totalAdditions <- allocMem :: IO (Ptr Word64) + totalDeletions <- allocMem :: IO (Ptr Word64) + onException (do + _ <- propagateGError $ ggit_patch_get_line_stats patch' totalContext totalAdditions totalDeletions + totalContext' <- peek totalContext + totalAdditions' <- peek totalAdditions + totalDeletions' <- peek totalDeletions + touchManagedPtr patch + freeMem totalContext + freeMem totalAdditions + freeMem totalDeletions + return (totalContext', totalAdditions', totalDeletions') + ) (do + freeMem totalContext + freeMem totalAdditions + freeMem totalDeletions + ) + +#if ENABLE_OVERLOADING +data PatchGetLineStatsMethodInfo +instance (signature ~ (m ((Word64, Word64, Word64))), MonadIO m) => O.MethodInfo PatchGetLineStatsMethodInfo Patch signature where + overloadedMethod _ = patchGetLineStats + +#endif + +-- method Patch::get_num_hunks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", 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_patch_get_num_hunks" ggit_patch_get_num_hunks :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + IO Word64 + +{- | +Get the number of hunks in the patch. +-} +patchGetNumHunks :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> m Word64 + {- ^ __Returns:__ the number of hunks. -} +patchGetNumHunks patch = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + result <- ggit_patch_get_num_hunks patch' + touchManagedPtr patch + return result + +#if ENABLE_OVERLOADING +data PatchGetNumHunksMethodInfo +instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo PatchGetNumHunksMethodInfo Patch signature where + overloadedMethod _ = patchGetNumHunks + +#endif + +-- method Patch::get_num_lines_in_hunk +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hunk", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hunk index.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_patch_get_num_lines_in_hunk" ggit_patch_get_num_lines_in_hunk :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + Word64 -> -- hunk : TBasicType TUInt64 + IO Int32 + +{- | +Get the number of lines in /@hunk@/. +-} +patchGetNumLinesInHunk :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> Word64 + {- ^ /@hunk@/: the hunk index. -} + -> m Int32 + {- ^ __Returns:__ the number of lines. -} +patchGetNumLinesInHunk patch hunk = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + result <- ggit_patch_get_num_lines_in_hunk patch' hunk + touchManagedPtr patch + return result + +#if ENABLE_OVERLOADING +data PatchGetNumLinesInHunkMethodInfo +instance (signature ~ (Word64 -> m Int32), MonadIO m) => O.MethodInfo PatchGetNumLinesInHunkMethodInfo Patch signature where + overloadedMethod _ = patchGetNumLinesInHunk + +#endif + +-- method Patch::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Patch"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_patch_ref" ggit_patch_ref :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + IO (Ptr Patch) + +{- | +Atomically increments the reference count of /@patch@/ by one. +This function is MT-safe and may be called from any thread. +-} +patchRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> m (Maybe Patch) + {- ^ __Returns:__ a 'GI.Ggit.Structs.Patch.Patch' or 'Nothing'. -} +patchRef patch = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + result <- ggit_patch_ref patch' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Patch) result' + return result'' + touchManagedPtr patch + return maybeResult + +#if ENABLE_OVERLOADING +data PatchRefMethodInfo +instance (signature ~ (m (Maybe Patch)), MonadIO m) => O.MethodInfo PatchRefMethodInfo Patch signature where + overloadedMethod _ = patchRef + +#endif + +-- method Patch::to_stream +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_patch_to_stream" ggit_patch_to_stream :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + Ptr Gio.OutputStream.OutputStream -> -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Write the contents of a patch to the provided stream. +-} +patchToStream :: + (B.CallStack.HasCallStack, MonadIO m, Gio.OutputStream.IsOutputStream a) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> a + {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +patchToStream patch stream = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + stream' <- unsafeManagedPtrCastPtr stream + onException (do + _ <- propagateGError $ ggit_patch_to_stream patch' stream' + touchManagedPtr patch + touchManagedPtr stream + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data PatchToStreamMethodInfo +instance (signature ~ (a -> m ()), MonadIO m, Gio.OutputStream.IsOutputStream a) => O.MethodInfo PatchToStreamMethodInfo Patch signature where + overloadedMethod _ = patchToStream + +#endif + +-- method Patch::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_patch_to_string" ggit_patch_to_string :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + Ptr (Ptr GError) -> -- error + IO CString + +{- | +Gets the content of a patch as a single diff text. +-} +patchToString :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the content of a patch as a single diff text or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +patchToString patch = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + onException (do + result <- propagateGError $ ggit_patch_to_string patch' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr patch + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data PatchToStringMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo PatchToStringMethodInfo Patch signature where + overloadedMethod _ = patchToString + +#endif + +-- method Patch::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "patch", argType = TInterface (Name {namespace = "Ggit", name = "Patch"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitPatch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_patch_unref" ggit_patch_unref :: + Ptr Patch -> -- patch : TInterface (Name {namespace = "Ggit", name = "Patch"}) + IO () + +{- | +Atomically decrements the reference count of /@patch@/ by one. +If the reference count drops to 0, /@patch@/ is freed. +-} +patchUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Patch + {- ^ /@patch@/: a 'GI.Ggit.Structs.Patch.Patch'. -} + -> m () +patchUnref patch = liftIO $ do + patch' <- unsafeManagedPtrGetPtr patch + ggit_patch_unref patch' + touchManagedPtr patch + return () + +#if ENABLE_OVERLOADING +data PatchUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo PatchUnrefMethodInfo Patch signature where + overloadedMethod _ = patchUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolvePatchMethod (t :: Symbol) (o :: *) :: * where + ResolvePatchMethod "ref" o = PatchRefMethodInfo + ResolvePatchMethod "toStream" o = PatchToStreamMethodInfo + ResolvePatchMethod "toString" o = PatchToStringMethodInfo + ResolvePatchMethod "unref" o = PatchUnrefMethodInfo + ResolvePatchMethod "getDelta" o = PatchGetDeltaMethodInfo + ResolvePatchMethod "getHunk" o = PatchGetHunkMethodInfo + ResolvePatchMethod "getLineStats" o = PatchGetLineStatsMethodInfo + ResolvePatchMethod "getNumHunks" o = PatchGetNumHunksMethodInfo + ResolvePatchMethod "getNumLinesInHunk" o = PatchGetNumLinesInHunkMethodInfo + ResolvePatchMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePatchMethod t Patch, O.MethodInfo info Patch p) => OL.IsLabel t (Patch -> 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 + + diff --git a/GI/Ggit/Structs/Patch.hs-boot b/GI/Ggit/Structs/Patch.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Patch.hs-boot @@ -0,0 +1,53 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.Patch 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 + +newtype Patch = Patch (ManagedPtr Patch) +instance BoxedObject Patch where +#if ENABLE_OVERLOADING +data PatchGetDeltaMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchGetHunkMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchGetLineStatsMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchGetNumHunksMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchGetNumLinesInHunkMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchToStreamMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchToStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data PatchUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/RebaseOperation.hs b/GI/Ggit/Structs/RebaseOperation.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RebaseOperation.hs @@ -0,0 +1,310 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a rebase operation. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.RebaseOperation + ( + +-- * Exported types + RebaseOperation(..) , + noRebaseOperation , + + + -- * Methods +-- ** getExec #method:getExec# + +#if ENABLE_OVERLOADING + RebaseOperationGetExecMethodInfo , +#endif + rebaseOperationGetExec , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + RebaseOperationGetIdMethodInfo , +#endif + rebaseOperationGetId , + + +-- ** getOperationType #method:getOperationType# + +#if ENABLE_OVERLOADING + RebaseOperationGetOperationTypeMethodInfo, +#endif + rebaseOperationGetOperationType , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + RebaseOperationRefMethodInfo , +#endif + rebaseOperationRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + RebaseOperationUnrefMethodInfo , +#endif + rebaseOperationUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype RebaseOperation = RebaseOperation (ManagedPtr RebaseOperation) +foreign import ccall "ggit_rebase_operation_get_type" c_ggit_rebase_operation_get_type :: + IO GType + +instance BoxedObject RebaseOperation where + boxedType _ = c_ggit_rebase_operation_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `RebaseOperation`. +noRebaseOperation :: Maybe RebaseOperation +noRebaseOperation = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RebaseOperation +type instance O.AttributeList RebaseOperation = RebaseOperationAttributeList +type RebaseOperationAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RebaseOperation::get_exec +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_operation", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_operation_get_exec" ggit_rebase_operation_get_exec :: + Ptr RebaseOperation -> -- rebase_operation : TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}) + IO CString + +{- | +Gets the executable the user has requested be run. This will only +be populated for operations of type /@gGITREBASEOPERATIONEXEC@/. +-} +rebaseOperationGetExec :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOperation + {- ^ /@rebaseOperation@/: a 'GI.Ggit.Structs.RebaseOperation.RebaseOperation'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the executable the user has requested be run or 'Nothing'. -} +rebaseOperationGetExec rebaseOperation = liftIO $ do + rebaseOperation' <- unsafeManagedPtrGetPtr rebaseOperation + result <- ggit_rebase_operation_get_exec rebaseOperation' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr rebaseOperation + return maybeResult + +#if ENABLE_OVERLOADING +data RebaseOperationGetExecMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo RebaseOperationGetExecMethodInfo RebaseOperation signature where + overloadedMethod _ = rebaseOperationGetExec + +#endif + +-- method RebaseOperation::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_operation", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_operation_get_id" ggit_rebase_operation_get_id :: + Ptr RebaseOperation -> -- rebase_operation : TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the commit ID being cherry-picked. This will be populated for +all operations except those of type /@gGITREBASEOPERATIONEXEC@/. +-} +rebaseOperationGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOperation + {- ^ /@rebaseOperation@/: a 'GI.Ggit.Structs.RebaseOperation.RebaseOperation'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the commit ID being cherry-picked or 'Nothing'. -} +rebaseOperationGetId rebaseOperation = liftIO $ do + rebaseOperation' <- unsafeManagedPtrGetPtr rebaseOperation + result <- ggit_rebase_operation_get_id rebaseOperation' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr rebaseOperation + return maybeResult + +#if ENABLE_OVERLOADING +data RebaseOperationGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo RebaseOperationGetIdMethodInfo RebaseOperation signature where + overloadedMethod _ = rebaseOperationGetId + +#endif + +-- method RebaseOperation::get_operation_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_operation", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RebaseOperationType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_operation_get_operation_type" ggit_rebase_operation_get_operation_type :: + Ptr RebaseOperation -> -- rebase_operation : TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}) + IO CUInt + +{- | +Gets the type of rebase operation. +-} +rebaseOperationGetOperationType :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOperation + {- ^ /@rebaseOperation@/: a 'GI.Ggit.Structs.RebaseOperation.RebaseOperation'. -} + -> m Ggit.Enums.RebaseOperationType + {- ^ __Returns:__ a 'GI.Ggit.Enums.RebaseOperationType'. -} +rebaseOperationGetOperationType rebaseOperation = liftIO $ do + rebaseOperation' <- unsafeManagedPtrGetPtr rebaseOperation + result <- ggit_rebase_operation_get_operation_type rebaseOperation' + let result' = (toEnum . fromIntegral) result + touchManagedPtr rebaseOperation + return result' + +#if ENABLE_OVERLOADING +data RebaseOperationGetOperationTypeMethodInfo +instance (signature ~ (m Ggit.Enums.RebaseOperationType), MonadIO m) => O.MethodInfo RebaseOperationGetOperationTypeMethodInfo RebaseOperation signature where + overloadedMethod _ = rebaseOperationGetOperationType + +#endif + +-- method RebaseOperation::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_operation", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RebaseOperation"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_operation_ref" ggit_rebase_operation_ref :: + Ptr RebaseOperation -> -- rebase_operation : TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}) + IO (Ptr RebaseOperation) + +{- | +Atomically increments the reference count of /@rebaseOperation@/ by one. +This function is MT-safe and may be called from any thread. +-} +rebaseOperationRef :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOperation + {- ^ /@rebaseOperation@/: a 'GI.Ggit.Structs.RebaseOperation.RebaseOperation'. -} + -> m (Maybe RebaseOperation) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.RebaseOperation.RebaseOperation' or 'Nothing'. -} +rebaseOperationRef rebaseOperation = liftIO $ do + rebaseOperation' <- unsafeManagedPtrGetPtr rebaseOperation + result <- ggit_rebase_operation_ref rebaseOperation' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed RebaseOperation) result' + return result'' + touchManagedPtr rebaseOperation + return maybeResult + +#if ENABLE_OVERLOADING +data RebaseOperationRefMethodInfo +instance (signature ~ (m (Maybe RebaseOperation)), MonadIO m) => O.MethodInfo RebaseOperationRefMethodInfo RebaseOperation signature where + overloadedMethod _ = rebaseOperationRef + +#endif + +-- method RebaseOperation::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_operation", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_operation_unref" ggit_rebase_operation_unref :: + Ptr RebaseOperation -> -- rebase_operation : TInterface (Name {namespace = "Ggit", name = "RebaseOperation"}) + IO () + +{- | +Atomically decrements the reference count of /@rebaseOperation@/ by one. +If the reference count drops to 0, /@rebaseOperation@/ is freed. +-} +rebaseOperationUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOperation + {- ^ /@rebaseOperation@/: a 'GI.Ggit.Structs.RebaseOperation.RebaseOperation'. -} + -> m () +rebaseOperationUnref rebaseOperation = liftIO $ do + rebaseOperation' <- unsafeManagedPtrGetPtr rebaseOperation + ggit_rebase_operation_unref rebaseOperation' + touchManagedPtr rebaseOperation + return () + +#if ENABLE_OVERLOADING +data RebaseOperationUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RebaseOperationUnrefMethodInfo RebaseOperation signature where + overloadedMethod _ = rebaseOperationUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRebaseOperationMethod (t :: Symbol) (o :: *) :: * where + ResolveRebaseOperationMethod "ref" o = RebaseOperationRefMethodInfo + ResolveRebaseOperationMethod "unref" o = RebaseOperationUnrefMethodInfo + ResolveRebaseOperationMethod "getExec" o = RebaseOperationGetExecMethodInfo + ResolveRebaseOperationMethod "getId" o = RebaseOperationGetIdMethodInfo + ResolveRebaseOperationMethod "getOperationType" o = RebaseOperationGetOperationTypeMethodInfo + ResolveRebaseOperationMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRebaseOperationMethod t RebaseOperation, O.MethodInfo info RebaseOperation p) => OL.IsLabel t (RebaseOperation -> 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 + + diff --git a/GI/Ggit/Structs/RebaseOperation.hs-boot b/GI/Ggit/Structs/RebaseOperation.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RebaseOperation.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.RebaseOperation 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 + +newtype RebaseOperation = RebaseOperation (ManagedPtr RebaseOperation) +instance BoxedObject RebaseOperation where +#if ENABLE_OVERLOADING +data RebaseOperationGetExecMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOperationGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOperationGetOperationTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOperationRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOperationUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/RebaseOptions.hs b/GI/Ggit/Structs/RebaseOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RebaseOptions.hs @@ -0,0 +1,485 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when rebasing. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.RebaseOptions + ( + +-- * Exported types + RebaseOptions(..) , + noRebaseOptions , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + RebaseOptionsCopyMethodInfo , +#endif + rebaseOptionsCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + RebaseOptionsFreeMethodInfo , +#endif + rebaseOptionsFree , + + +-- ** getCheckoutOptions #method:getCheckoutOptions# + +#if ENABLE_OVERLOADING + RebaseOptionsGetCheckoutOptionsMethodInfo, +#endif + rebaseOptionsGetCheckoutOptions , + + +-- ** getQuiet #method:getQuiet# + +#if ENABLE_OVERLOADING + RebaseOptionsGetQuietMethodInfo , +#endif + rebaseOptionsGetQuiet , + + +-- ** getRewriteNotesRef #method:getRewriteNotesRef# + +#if ENABLE_OVERLOADING + RebaseOptionsGetRewriteNotesRefMethodInfo, +#endif + rebaseOptionsGetRewriteNotesRef , + + +-- ** new #method:new# + + rebaseOptionsNew , + + +-- ** setCheckoutOptions #method:setCheckoutOptions# + +#if ENABLE_OVERLOADING + RebaseOptionsSetCheckoutOptionsMethodInfo, +#endif + rebaseOptionsSetCheckoutOptions , + + +-- ** setQuiet #method:setQuiet# + +#if ENABLE_OVERLOADING + RebaseOptionsSetQuietMethodInfo , +#endif + rebaseOptionsSetQuiet , + + +-- ** setRewriteNotesRef #method:setRewriteNotesRef# + +#if ENABLE_OVERLOADING + RebaseOptionsSetRewriteNotesRefMethodInfo, +#endif + rebaseOptionsSetRewriteNotesRef , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.CheckoutOptions as Ggit.CheckoutOptions + +-- | Memory-managed wrapper type. +newtype RebaseOptions = RebaseOptions (ManagedPtr RebaseOptions) +foreign import ccall "ggit_rebase_options_get_type" c_ggit_rebase_options_get_type :: + IO GType + +instance BoxedObject RebaseOptions where + boxedType _ = c_ggit_rebase_options_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `RebaseOptions`. +noRebaseOptions :: Maybe RebaseOptions +noRebaseOptions = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RebaseOptions +type instance O.AttributeList RebaseOptions = RebaseOptionsAttributeList +type RebaseOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RebaseOptions::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_new" ggit_rebase_options_new :: + IO (Ptr RebaseOptions) + +{- | +Creates a new 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. +-} +rebaseOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m RebaseOptions + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} +rebaseOptionsNew = liftIO $ do + result <- ggit_rebase_options_new + checkUnexpectedReturnNULL "rebaseOptionsNew" result + result' <- (wrapBoxed RebaseOptions) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method RebaseOptions::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RebaseOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_copy" ggit_rebase_options_copy :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + IO (Ptr RebaseOptions) + +{- | +Copies /@rebaseOptions@/ into a newly allocated 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. +-} +rebaseOptionsCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOptions + {- ^ /@rebaseOptions@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} + -> m (Maybe RebaseOptions) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.RebaseOptions.RebaseOptions' or 'Nothing'. -} +rebaseOptionsCopy rebaseOptions = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + result <- ggit_rebase_options_copy rebaseOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed RebaseOptions) result' + return result'' + touchManagedPtr rebaseOptions + return maybeResult + +#if ENABLE_OVERLOADING +data RebaseOptionsCopyMethodInfo +instance (signature ~ (m (Maybe RebaseOptions)), MonadIO m) => O.MethodInfo RebaseOptionsCopyMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsCopy + +#endif + +-- method RebaseOptions::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_free" ggit_rebase_options_free :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + IO () + +{- | +Frees /@rebaseOptions@/. +-} +rebaseOptionsFree :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOptions + {- ^ /@rebaseOptions@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} + -> m () +rebaseOptionsFree rebaseOptions = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + ggit_rebase_options_free rebaseOptions' + touchManagedPtr rebaseOptions + return () + +#if ENABLE_OVERLOADING +data RebaseOptionsFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RebaseOptionsFreeMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsFree + +#endif + +-- method RebaseOptions::get_checkout_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_get_checkout_options" ggit_rebase_options_get_checkout_options :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + IO (Ptr Ggit.CheckoutOptions.CheckoutOptions) + +{- | +Get the checkout options object or 'Nothing' if not set. +-} +rebaseOptionsGetCheckoutOptions :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOptions + {- ^ /@rebaseOptions@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} + -> m (Maybe Ggit.CheckoutOptions.CheckoutOptions) + {- ^ __Returns:__ the checkout options or 'Nothing'. -} +rebaseOptionsGetCheckoutOptions rebaseOptions = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + result <- ggit_rebase_options_get_checkout_options rebaseOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.CheckoutOptions.CheckoutOptions) result' + return result'' + touchManagedPtr rebaseOptions + return maybeResult + +#if ENABLE_OVERLOADING +data RebaseOptionsGetCheckoutOptionsMethodInfo +instance (signature ~ (m (Maybe Ggit.CheckoutOptions.CheckoutOptions)), MonadIO m) => O.MethodInfo RebaseOptionsGetCheckoutOptionsMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsGetCheckoutOptions + +#endif + +-- method RebaseOptions::get_quiet +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_get_quiet" ggit_rebase_options_get_quiet :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + IO CInt + +{- | +Gets whether you want a quiet rebase experience. +-} +rebaseOptionsGetQuiet :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOptions + {- ^ /@rebaseOptions@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} + -> m Bool + {- ^ __Returns:__ returns whether you want a quiet rebase experience. -} +rebaseOptionsGetQuiet rebaseOptions = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + result <- ggit_rebase_options_get_quiet rebaseOptions' + let result' = (/= 0) result + touchManagedPtr rebaseOptions + return result' + +#if ENABLE_OVERLOADING +data RebaseOptionsGetQuietMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo RebaseOptionsGetQuietMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsGetQuiet + +#endif + +-- method RebaseOptions::get_rewrite_notes_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_get_rewrite_notes_ref" ggit_rebase_options_get_rewrite_notes_ref :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + IO CString + +{- | +Gets the the name of the notes reference used to rewrite notes for rebased +commits when finishing the rebase or 'Nothing' if not set. +-} +rebaseOptionsGetRewriteNotesRef :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOptions + {- ^ /@rebaseOptions@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of the notes reference or 'Nothing'. -} +rebaseOptionsGetRewriteNotesRef rebaseOptions = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + result <- ggit_rebase_options_get_rewrite_notes_ref rebaseOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr rebaseOptions + return maybeResult + +#if ENABLE_OVERLOADING +data RebaseOptionsGetRewriteNotesRefMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo RebaseOptionsGetRewriteNotesRefMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsGetRewriteNotesRef + +#endif + +-- method RebaseOptions::set_checkout_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checkout_options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_set_checkout_options" ggit_rebase_options_set_checkout_options :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- checkout_options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO () + +{- | +/No description available in the introspection data./ +-} +rebaseOptionsSetCheckoutOptions :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.CheckoutOptions.IsCheckoutOptions a) => + RebaseOptions + -> a + -> m () +rebaseOptionsSetCheckoutOptions rebaseOptions checkoutOptions = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + checkoutOptions' <- unsafeManagedPtrCastPtr checkoutOptions + ggit_rebase_options_set_checkout_options rebaseOptions' checkoutOptions' + touchManagedPtr rebaseOptions + touchManagedPtr checkoutOptions + return () + +#if ENABLE_OVERLOADING +data RebaseOptionsSetCheckoutOptionsMethodInfo +instance (signature ~ (a -> m ()), MonadIO m, Ggit.CheckoutOptions.IsCheckoutOptions a) => O.MethodInfo RebaseOptionsSetCheckoutOptionsMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsSetCheckoutOptions + +#endif + +-- method RebaseOptions::set_quiet +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quiet", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether you want a quiet rebase experience.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_set_quiet" ggit_rebase_options_set_quiet :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + CInt -> -- quiet : TBasicType TBoolean + IO () + +{- | +Used by @/ggit_rebase_init()/@, this will instruct other clients working +on this rebase that you want a quiet rebase experience, which they +may choose to provide in an application-specific manner. This has no +effect upon libgit2-glib directly, but is provided for interoperability +between Git tools. +-} +rebaseOptionsSetQuiet :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOptions + {- ^ /@rebaseOptions@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} + -> Bool + {- ^ /@quiet@/: whether you want a quiet rebase experience. -} + -> m () +rebaseOptionsSetQuiet rebaseOptions quiet = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + let quiet' = (fromIntegral . fromEnum) quiet + ggit_rebase_options_set_quiet rebaseOptions' quiet' + touchManagedPtr rebaseOptions + return () + +#if ENABLE_OVERLOADING +data RebaseOptionsSetQuietMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo RebaseOptionsSetQuietMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsSetQuiet + +#endif + +-- method RebaseOptions::set_rewrite_notes_ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rebase_options", argType = TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRebaseOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rewrite_notes_ref", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the notes reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_rebase_options_set_rewrite_notes_ref" ggit_rebase_options_set_rewrite_notes_ref :: + Ptr RebaseOptions -> -- rebase_options : TInterface (Name {namespace = "Ggit", name = "RebaseOptions"}) + CString -> -- rewrite_notes_ref : TBasicType TUTF8 + IO () + +{- | +Used by 'GI.Ggit.Objects.Rebase.rebaseFinish', this is the name of the notes reference +used to rewrite notes for rebased commits when finishing the rebase; +if 'Nothing', the contents of the configuration option @notes.rewriteRef@ +is examined, unless the configuration option @notes.rewrite.rebase@ +is set to false. If @notes.rewriteRef@ is also 'Nothing', notes will +not be rewritten. +-} +rebaseOptionsSetRewriteNotesRef :: + (B.CallStack.HasCallStack, MonadIO m) => + RebaseOptions + {- ^ /@rebaseOptions@/: a 'GI.Ggit.Structs.RebaseOptions.RebaseOptions'. -} + -> T.Text + {- ^ /@rewriteNotesRef@/: the name of the notes reference. -} + -> m () +rebaseOptionsSetRewriteNotesRef rebaseOptions rewriteNotesRef = liftIO $ do + rebaseOptions' <- unsafeManagedPtrGetPtr rebaseOptions + rewriteNotesRef' <- textToCString rewriteNotesRef + ggit_rebase_options_set_rewrite_notes_ref rebaseOptions' rewriteNotesRef' + touchManagedPtr rebaseOptions + freeMem rewriteNotesRef' + return () + +#if ENABLE_OVERLOADING +data RebaseOptionsSetRewriteNotesRefMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo RebaseOptionsSetRewriteNotesRefMethodInfo RebaseOptions signature where + overloadedMethod _ = rebaseOptionsSetRewriteNotesRef + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRebaseOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveRebaseOptionsMethod "copy" o = RebaseOptionsCopyMethodInfo + ResolveRebaseOptionsMethod "free" o = RebaseOptionsFreeMethodInfo + ResolveRebaseOptionsMethod "getCheckoutOptions" o = RebaseOptionsGetCheckoutOptionsMethodInfo + ResolveRebaseOptionsMethod "getQuiet" o = RebaseOptionsGetQuietMethodInfo + ResolveRebaseOptionsMethod "getRewriteNotesRef" o = RebaseOptionsGetRewriteNotesRefMethodInfo + ResolveRebaseOptionsMethod "setCheckoutOptions" o = RebaseOptionsSetCheckoutOptionsMethodInfo + ResolveRebaseOptionsMethod "setQuiet" o = RebaseOptionsSetQuietMethodInfo + ResolveRebaseOptionsMethod "setRewriteNotesRef" o = RebaseOptionsSetRewriteNotesRefMethodInfo + ResolveRebaseOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRebaseOptionsMethod t RebaseOptions, O.MethodInfo info RebaseOptions p) => OL.IsLabel t (RebaseOptions -> 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 + + diff --git a/GI/Ggit/Structs/RebaseOptions.hs-boot b/GI/Ggit/Structs/RebaseOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RebaseOptions.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.RebaseOptions 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 + +newtype RebaseOptions = RebaseOptions (ManagedPtr RebaseOptions) +instance BoxedObject RebaseOptions where +#if ENABLE_OVERLOADING +data RebaseOptionsCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOptionsFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOptionsGetCheckoutOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOptionsGetQuietMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOptionsGetRewriteNotesRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOptionsSetCheckoutOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOptionsSetQuietMethodInfo +#endif +#if ENABLE_OVERLOADING +data RebaseOptionsSetRewriteNotesRefMethodInfo +#endif diff --git a/GI/Ggit/Structs/RefSpec.hs b/GI/Ggit/Structs/RefSpec.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RefSpec.hs @@ -0,0 +1,306 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Reprensents a git reference specification. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.RefSpec + ( + +-- * Exported types + RefSpec(..) , + noRefSpec , + + + -- * Methods +-- ** getDestination #method:getDestination# + +#if ENABLE_OVERLOADING + RefSpecGetDestinationMethodInfo , +#endif + refSpecGetDestination , + + +-- ** getSource #method:getSource# + +#if ENABLE_OVERLOADING + RefSpecGetSourceMethodInfo , +#endif + refSpecGetSource , + + +-- ** isForced #method:isForced# + +#if ENABLE_OVERLOADING + RefSpecIsForcedMethodInfo , +#endif + refSpecIsForced , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + RefSpecRefMethodInfo , +#endif + refSpecRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + RefSpecUnrefMethodInfo , +#endif + refSpecUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype RefSpec = RefSpec (ManagedPtr RefSpec) +foreign import ccall "ggit_ref_spec_get_type" c_ggit_ref_spec_get_type :: + IO GType + +instance BoxedObject RefSpec where + boxedType _ = c_ggit_ref_spec_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `RefSpec`. +noRefSpec :: Maybe RefSpec +noRefSpec = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RefSpec +type instance O.AttributeList RefSpec = RefSpecAttributeList +type RefSpecAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RefSpec::get_destination +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "refspec", argType = TInterface (Name {namespace = "Ggit", name = "RefSpec"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRefSpec.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_spec_get_destination" ggit_ref_spec_get_destination :: + Ptr RefSpec -> -- refspec : TInterface (Name {namespace = "Ggit", name = "RefSpec"}) + IO CString + +{- | +Gets the /@refspec@/\'s destination. +-} +refSpecGetDestination :: + (B.CallStack.HasCallStack, MonadIO m) => + RefSpec + {- ^ /@refspec@/: a 'GI.Ggit.Structs.RefSpec.RefSpec'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the refspec\'s destination or 'Nothing'. -} +refSpecGetDestination refspec = liftIO $ do + refspec' <- unsafeManagedPtrGetPtr refspec + result <- ggit_ref_spec_get_destination refspec' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr refspec + return maybeResult + +#if ENABLE_OVERLOADING +data RefSpecGetDestinationMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo RefSpecGetDestinationMethodInfo RefSpec signature where + overloadedMethod _ = refSpecGetDestination + +#endif + +-- method RefSpec::get_source +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "refspec", argType = TInterface (Name {namespace = "Ggit", name = "RefSpec"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRefSpec.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_spec_get_source" ggit_ref_spec_get_source :: + Ptr RefSpec -> -- refspec : TInterface (Name {namespace = "Ggit", name = "RefSpec"}) + IO CString + +{- | +Gets the /@refspec@/\'s source. +-} +refSpecGetSource :: + (B.CallStack.HasCallStack, MonadIO m) => + RefSpec + {- ^ /@refspec@/: a 'GI.Ggit.Structs.RefSpec.RefSpec'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the refspec\'s source or 'Nothing'. -} +refSpecGetSource refspec = liftIO $ do + refspec' <- unsafeManagedPtrGetPtr refspec + result <- ggit_ref_spec_get_source refspec' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr refspec + return maybeResult + +#if ENABLE_OVERLOADING +data RefSpecGetSourceMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo RefSpecGetSourceMethodInfo RefSpec signature where + overloadedMethod _ = refSpecGetSource + +#endif + +-- method RefSpec::is_forced +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "refspec", argType = TInterface (Name {namespace = "Ggit", name = "RefSpec"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRefSpec.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_spec_is_forced" ggit_ref_spec_is_forced :: + Ptr RefSpec -> -- refspec : TInterface (Name {namespace = "Ggit", name = "RefSpec"}) + IO CInt + +{- | +Whether updating is done forcefully. +-} +refSpecIsForced :: + (B.CallStack.HasCallStack, MonadIO m) => + RefSpec + {- ^ /@refspec@/: a 'GI.Ggit.Structs.RefSpec.RefSpec'. -} + -> m Bool + {- ^ __Returns:__ if updating is done forcefully. -} +refSpecIsForced refspec = liftIO $ do + refspec' <- unsafeManagedPtrGetPtr refspec + result <- ggit_ref_spec_is_forced refspec' + let result' = (/= 0) result + touchManagedPtr refspec + return result' + +#if ENABLE_OVERLOADING +data RefSpecIsForcedMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo RefSpecIsForcedMethodInfo RefSpec signature where + overloadedMethod _ = refSpecIsForced + +#endif + +-- method RefSpec::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "refspec", argType = TInterface (Name {namespace = "Ggit", name = "RefSpec"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRefSpec.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RefSpec"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_spec_ref" ggit_ref_spec_ref :: + Ptr RefSpec -> -- refspec : TInterface (Name {namespace = "Ggit", name = "RefSpec"}) + IO (Ptr RefSpec) + +{- | +Atomically increments the reference count of /@refspec@/ by one. +This function is MT-safe and may be called from any thread. +-} +refSpecRef :: + (B.CallStack.HasCallStack, MonadIO m) => + RefSpec + {- ^ /@refspec@/: a 'GI.Ggit.Structs.RefSpec.RefSpec'. -} + -> m (Maybe RefSpec) + {- ^ __Returns:__ a 'GI.Ggit.Structs.RefSpec.RefSpec' or 'Nothing'. -} +refSpecRef refspec = liftIO $ do + refspec' <- unsafeManagedPtrGetPtr refspec + result <- ggit_ref_spec_ref refspec' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed RefSpec) result' + return result'' + touchManagedPtr refspec + return maybeResult + +#if ENABLE_OVERLOADING +data RefSpecRefMethodInfo +instance (signature ~ (m (Maybe RefSpec)), MonadIO m) => O.MethodInfo RefSpecRefMethodInfo RefSpec signature where + overloadedMethod _ = refSpecRef + +#endif + +-- method RefSpec::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "refspec", argType = TInterface (Name {namespace = "Ggit", name = "RefSpec"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRefSpec.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_ref_spec_unref" ggit_ref_spec_unref :: + Ptr RefSpec -> -- refspec : TInterface (Name {namespace = "Ggit", name = "RefSpec"}) + IO () + +{- | +Atomically decrements the reference count of /@refspec@/ by one. +If the reference count drops to 0, /@refspec@/ is freed. +-} +refSpecUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + RefSpec + {- ^ /@refspec@/: a 'GI.Ggit.Structs.RefSpec.RefSpec'. -} + -> m () +refSpecUnref refspec = liftIO $ do + refspec' <- unsafeManagedPtrGetPtr refspec + ggit_ref_spec_unref refspec' + touchManagedPtr refspec + return () + +#if ENABLE_OVERLOADING +data RefSpecUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RefSpecUnrefMethodInfo RefSpec signature where + overloadedMethod _ = refSpecUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRefSpecMethod (t :: Symbol) (o :: *) :: * where + ResolveRefSpecMethod "isForced" o = RefSpecIsForcedMethodInfo + ResolveRefSpecMethod "ref" o = RefSpecRefMethodInfo + ResolveRefSpecMethod "unref" o = RefSpecUnrefMethodInfo + ResolveRefSpecMethod "getDestination" o = RefSpecGetDestinationMethodInfo + ResolveRefSpecMethod "getSource" o = RefSpecGetSourceMethodInfo + ResolveRefSpecMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRefSpecMethod t RefSpec, O.MethodInfo info RefSpec p) => OL.IsLabel t (RefSpec -> 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 + + diff --git a/GI/Ggit/Structs/RefSpec.hs-boot b/GI/Ggit/Structs/RefSpec.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RefSpec.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.RefSpec 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 + +newtype RefSpec = RefSpec (ManagedPtr RefSpec) +instance BoxedObject RefSpec where +#if ENABLE_OVERLOADING +data RefSpecGetDestinationMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefSpecGetSourceMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefSpecIsForcedMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefSpecRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RefSpecUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/Reflog.hs b/GI/Ggit/Structs/Reflog.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Reflog.hs @@ -0,0 +1,429 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a reflog. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.Reflog + ( + +-- * Exported types + Reflog(..) , + noReflog , + + + -- * Methods +-- ** append #method:append# + +#if ENABLE_OVERLOADING + ReflogAppendMethodInfo , +#endif + reflogAppend , + + +-- ** getEntryCount #method:getEntryCount# + +#if ENABLE_OVERLOADING + ReflogGetEntryCountMethodInfo , +#endif + reflogGetEntryCount , + + +-- ** getEntryFromIndex #method:getEntryFromIndex# + +#if ENABLE_OVERLOADING + ReflogGetEntryFromIndexMethodInfo , +#endif + reflogGetEntryFromIndex , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + ReflogRefMethodInfo , +#endif + reflogRef , + + +-- ** rename #method:rename# + +#if ENABLE_OVERLOADING + ReflogRenameMethodInfo , +#endif + reflogRename , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + ReflogUnrefMethodInfo , +#endif + reflogUnref , + + +-- ** write #method:write# + +#if ENABLE_OVERLOADING + ReflogWriteMethodInfo , +#endif + reflogWrite , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId +import {-# SOURCE #-} qualified GI.Ggit.Structs.ReflogEntry as Ggit.ReflogEntry + +-- | Memory-managed wrapper type. +newtype Reflog = Reflog (ManagedPtr Reflog) +foreign import ccall "ggit_reflog_get_type" c_ggit_reflog_get_type :: + IO GType + +instance BoxedObject Reflog where + boxedType _ = c_ggit_reflog_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Reflog`. +noReflog :: Maybe Reflog +noReflog = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Reflog +type instance O.AttributeList Reflog = ReflogAttributeList +type ReflogAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Reflog::append +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_reflog_append" ggit_reflog_append :: + Ptr Reflog -> -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"}) + Ptr Ggit.OId.OId -> -- oid : TInterface (Name {namespace = "Ggit", name = "OId"}) + Ptr Ggit.Signature.Signature -> -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"}) + CString -> -- message : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Creates a reflog entry. +-} +reflogAppend :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.Signature.IsSignature a) => + Reflog + {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -} + -> Ggit.OId.OId + {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -} + -> a + {- ^ /@committer@/: a 'GI.Ggit.Objects.Signature.Signature'. -} + -> T.Text + {- ^ /@message@/: the message. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +reflogAppend reflog oid committer message = liftIO $ do + reflog' <- unsafeManagedPtrGetPtr reflog + oid' <- unsafeManagedPtrGetPtr oid + committer' <- unsafeManagedPtrCastPtr committer + message' <- textToCString message + onException (do + _ <- propagateGError $ ggit_reflog_append reflog' oid' committer' message' + touchManagedPtr reflog + touchManagedPtr oid + touchManagedPtr committer + freeMem message' + return () + ) (do + freeMem message' + ) + +#if ENABLE_OVERLOADING +data ReflogAppendMethodInfo +instance (signature ~ (Ggit.OId.OId -> a -> T.Text -> m ()), MonadIO m, Ggit.Signature.IsSignature a) => O.MethodInfo ReflogAppendMethodInfo Reflog signature where + overloadedMethod _ = reflogAppend + +#endif + +-- method Reflog::get_entry_count +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_get_entry_count" ggit_reflog_get_entry_count :: + Ptr Reflog -> -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"}) + IO Word32 + +{- | +Gets the number of log entries in /@reflog@/. +-} +reflogGetEntryCount :: + (B.CallStack.HasCallStack, MonadIO m) => + Reflog + {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -} + -> m Word32 + {- ^ __Returns:__ the number of log entries. -} +reflogGetEntryCount reflog = liftIO $ do + reflog' <- unsafeManagedPtrGetPtr reflog + result <- ggit_reflog_get_entry_count reflog' + touchManagedPtr reflog + return result + +#if ENABLE_OVERLOADING +data ReflogGetEntryCountMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo ReflogGetEntryCountMethodInfo Reflog signature where + overloadedMethod _ = reflogGetEntryCount + +#endif + +-- method Reflog::get_entry_from_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position to lookup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_get_entry_from_index" ggit_reflog_get_entry_from_index :: + Ptr Reflog -> -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"}) + Word32 -> -- idx : TBasicType TUInt + IO (Ptr Ggit.ReflogEntry.ReflogEntry) + +{- | +Gets the 'GI.Ggit.Structs.ReflogEntry.ReflogEntry' at /@idx@/ in /@reflog@/, or 'Nothing' if not found. +-} +reflogGetEntryFromIndex :: + (B.CallStack.HasCallStack, MonadIO m) => + Reflog + {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -} + -> Word32 + {- ^ /@idx@/: the position to lookup. -} + -> m (Maybe Ggit.ReflogEntry.ReflogEntry) + {- ^ __Returns:__ the reflog entry at the index, or 'Nothing' if not found. -} +reflogGetEntryFromIndex reflog idx = liftIO $ do + reflog' <- unsafeManagedPtrGetPtr reflog + result <- ggit_reflog_get_entry_from_index reflog' idx + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.ReflogEntry.ReflogEntry) result' + return result'' + touchManagedPtr reflog + return maybeResult + +#if ENABLE_OVERLOADING +data ReflogGetEntryFromIndexMethodInfo +instance (signature ~ (Word32 -> m (Maybe Ggit.ReflogEntry.ReflogEntry)), MonadIO m) => O.MethodInfo ReflogGetEntryFromIndexMethodInfo Reflog signature where + overloadedMethod _ = reflogGetEntryFromIndex + +#endif + +-- method Reflog::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Reflog"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_ref" ggit_reflog_ref :: + Ptr Reflog -> -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"}) + IO (Ptr Reflog) + +{- | +Atomically increments the reference count of /@reflog@/ by one. +This function is MT-safe and may be called from any thread. +-} +reflogRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Reflog + {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -} + -> m (Maybe Reflog) + {- ^ __Returns:__ the passed in 'GI.Ggit.Structs.Reflog.Reflog' or 'Nothing'. -} +reflogRef reflog = liftIO $ do + reflog' <- unsafeManagedPtrGetPtr reflog + result <- ggit_reflog_ref reflog' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Reflog) result' + return result'' + touchManagedPtr reflog + return maybeResult + +#if ENABLE_OVERLOADING +data ReflogRefMethodInfo +instance (signature ~ (m (Maybe Reflog)), MonadIO m) => O.MethodInfo ReflogRefMethodInfo Reflog signature where + overloadedMethod _ = reflogRef + +#endif + +-- method Reflog::rename +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new name of the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_reflog_rename" ggit_reflog_rename :: + Ptr Reflog -> -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"}) + CString -> -- new_name : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Renames the reflog for to /@newName@/, on error /@error@/ is set. +-} +reflogRename :: + (B.CallStack.HasCallStack, MonadIO m) => + Reflog + {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -} + -> T.Text + {- ^ /@newName@/: the new name of the reference. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +reflogRename reflog newName = liftIO $ do + reflog' <- unsafeManagedPtrGetPtr reflog + newName' <- textToCString newName + onException (do + _ <- propagateGError $ ggit_reflog_rename reflog' newName' + touchManagedPtr reflog + freeMem newName' + return () + ) (do + freeMem newName' + ) + +#if ENABLE_OVERLOADING +data ReflogRenameMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo ReflogRenameMethodInfo Reflog signature where + overloadedMethod _ = reflogRename + +#endif + +-- method Reflog::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_unref" ggit_reflog_unref :: + Ptr Reflog -> -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"}) + IO () + +{- | +Atomically decrements the reference count of /@reflog@/ by one. +If the reference count drops to 0, /@reflog@/ is freed. +-} +reflogUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Reflog + {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -} + -> m () +reflogUnref reflog = liftIO $ do + reflog' <- unsafeManagedPtrGetPtr reflog + ggit_reflog_unref reflog' + touchManagedPtr reflog + return () + +#if ENABLE_OVERLOADING +data ReflogUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ReflogUnrefMethodInfo Reflog signature where + overloadedMethod _ = reflogUnref + +#endif + +-- method Reflog::write +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_reflog_write" ggit_reflog_write :: + Ptr Reflog -> -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Write the reflog to disk. +-} +reflogWrite :: + (B.CallStack.HasCallStack, MonadIO m) => + Reflog + {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +reflogWrite reflog = liftIO $ do + reflog' <- unsafeManagedPtrGetPtr reflog + onException (do + _ <- propagateGError $ ggit_reflog_write reflog' + touchManagedPtr reflog + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data ReflogWriteMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ReflogWriteMethodInfo Reflog signature where + overloadedMethod _ = reflogWrite + +#endif + +#if ENABLE_OVERLOADING +type family ResolveReflogMethod (t :: Symbol) (o :: *) :: * where + ResolveReflogMethod "append" o = ReflogAppendMethodInfo + ResolveReflogMethod "ref" o = ReflogRefMethodInfo + ResolveReflogMethod "rename" o = ReflogRenameMethodInfo + ResolveReflogMethod "unref" o = ReflogUnrefMethodInfo + ResolveReflogMethod "write" o = ReflogWriteMethodInfo + ResolveReflogMethod "getEntryCount" o = ReflogGetEntryCountMethodInfo + ResolveReflogMethod "getEntryFromIndex" o = ReflogGetEntryFromIndexMethodInfo + ResolveReflogMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveReflogMethod t Reflog, O.MethodInfo info Reflog p) => OL.IsLabel t (Reflog -> 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 + + diff --git a/GI/Ggit/Structs/Reflog.hs-boot b/GI/Ggit/Structs/Reflog.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Reflog.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.Reflog 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 + +newtype Reflog = Reflog (ManagedPtr Reflog) +instance BoxedObject Reflog where +#if ENABLE_OVERLOADING +data ReflogAppendMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogGetEntryCountMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogGetEntryFromIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogRenameMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogUnrefMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogWriteMethodInfo +#endif diff --git a/GI/Ggit/Structs/ReflogEntry.hs b/GI/Ggit/Structs/ReflogEntry.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/ReflogEntry.hs @@ -0,0 +1,356 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a reflog entry. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.ReflogEntry + ( + +-- * Exported types + ReflogEntry(..) , + noReflogEntry , + + + -- * Methods +-- ** getCommitter #method:getCommitter# + +#if ENABLE_OVERLOADING + ReflogEntryGetCommitterMethodInfo , +#endif + reflogEntryGetCommitter , + + +-- ** getMessage #method:getMessage# + +#if ENABLE_OVERLOADING + ReflogEntryGetMessageMethodInfo , +#endif + reflogEntryGetMessage , + + +-- ** getNewId #method:getNewId# + +#if ENABLE_OVERLOADING + ReflogEntryGetNewIdMethodInfo , +#endif + reflogEntryGetNewId , + + +-- ** getOldId #method:getOldId# + +#if ENABLE_OVERLOADING + ReflogEntryGetOldIdMethodInfo , +#endif + reflogEntryGetOldId , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + ReflogEntryRefMethodInfo , +#endif + reflogEntryRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + ReflogEntryUnrefMethodInfo , +#endif + reflogEntryUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype ReflogEntry = ReflogEntry (ManagedPtr ReflogEntry) +foreign import ccall "ggit_reflog_entry_get_type" c_ggit_reflog_entry_get_type :: + IO GType + +instance BoxedObject ReflogEntry where + boxedType _ = c_ggit_reflog_entry_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `ReflogEntry`. +noReflogEntry :: Maybe ReflogEntry +noReflogEntry = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ReflogEntry +type instance O.AttributeList ReflogEntry = ReflogEntryAttributeList +type ReflogEntryAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method ReflogEntry::get_committer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog_entry", argType = TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflogEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Signature"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_entry_get_committer" ggit_reflog_entry_get_committer :: + Ptr ReflogEntry -> -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}) + IO (Ptr Ggit.Signature.Signature) + +{- | +Gets the committer as a 'GI.Ggit.Objects.Signature.Signature'. +-} +reflogEntryGetCommitter :: + (B.CallStack.HasCallStack, MonadIO m) => + ReflogEntry + {- ^ /@reflogEntry@/: a 'GI.Ggit.Structs.ReflogEntry.ReflogEntry'. -} + -> m (Maybe Ggit.Signature.Signature) + {- ^ __Returns:__ the committer or 'Nothing'. -} +reflogEntryGetCommitter reflogEntry = liftIO $ do + reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry + result <- ggit_reflog_entry_get_committer reflogEntry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Ggit.Signature.Signature) result' + return result'' + touchManagedPtr reflogEntry + return maybeResult + +#if ENABLE_OVERLOADING +data ReflogEntryGetCommitterMethodInfo +instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m) => O.MethodInfo ReflogEntryGetCommitterMethodInfo ReflogEntry signature where + overloadedMethod _ = reflogEntryGetCommitter + +#endif + +-- method ReflogEntry::get_message +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog_entry", argType = TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflogEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_entry_get_message" ggit_reflog_entry_get_message :: + Ptr ReflogEntry -> -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}) + IO CString + +{- | +Gets the message. +-} +reflogEntryGetMessage :: + (B.CallStack.HasCallStack, MonadIO m) => + ReflogEntry + {- ^ /@reflogEntry@/: a 'GI.Ggit.Structs.ReflogEntry.ReflogEntry'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the message or 'Nothing'. -} +reflogEntryGetMessage reflogEntry = liftIO $ do + reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry + result <- ggit_reflog_entry_get_message reflogEntry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr reflogEntry + return maybeResult + +#if ENABLE_OVERLOADING +data ReflogEntryGetMessageMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo ReflogEntryGetMessageMethodInfo ReflogEntry signature where + overloadedMethod _ = reflogEntryGetMessage + +#endif + +-- method ReflogEntry::get_new_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog_entry", argType = TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflogEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_entry_get_new_id" ggit_reflog_entry_get_new_id :: + Ptr ReflogEntry -> -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the new 'GI.Ggit.Structs.OId.OId'. +-} +reflogEntryGetNewId :: + (B.CallStack.HasCallStack, MonadIO m) => + ReflogEntry + {- ^ /@reflogEntry@/: a 'GI.Ggit.Structs.ReflogEntry.ReflogEntry'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the new oid or 'Nothing'. -} +reflogEntryGetNewId reflogEntry = liftIO $ do + reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry + result <- ggit_reflog_entry_get_new_id reflogEntry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr reflogEntry + return maybeResult + +#if ENABLE_OVERLOADING +data ReflogEntryGetNewIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo ReflogEntryGetNewIdMethodInfo ReflogEntry signature where + overloadedMethod _ = reflogEntryGetNewId + +#endif + +-- method ReflogEntry::get_old_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog_entry", argType = TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflogEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_entry_get_old_id" ggit_reflog_entry_get_old_id :: + Ptr ReflogEntry -> -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the old 'GI.Ggit.Structs.OId.OId'. +-} +reflogEntryGetOldId :: + (B.CallStack.HasCallStack, MonadIO m) => + ReflogEntry + {- ^ /@reflogEntry@/: a 'GI.Ggit.Structs.ReflogEntry.ReflogEntry'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the old oid or 'Nothing'. -} +reflogEntryGetOldId reflogEntry = liftIO $ do + reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry + result <- ggit_reflog_entry_get_old_id reflogEntry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr reflogEntry + return maybeResult + +#if ENABLE_OVERLOADING +data ReflogEntryGetOldIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo ReflogEntryGetOldIdMethodInfo ReflogEntry signature where + overloadedMethod _ = reflogEntryGetOldId + +#endif + +-- method ReflogEntry::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog_entry", argType = TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflogEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_entry_ref" ggit_reflog_entry_ref :: + Ptr ReflogEntry -> -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}) + IO (Ptr ReflogEntry) + +{- | +Atomically increments the reference count of /@reflogEntry@/ by one. +This function is MT-safe and may be called from any thread. +-} +reflogEntryRef :: + (B.CallStack.HasCallStack, MonadIO m) => + ReflogEntry + {- ^ /@reflogEntry@/: a 'GI.Ggit.Structs.ReflogEntry.ReflogEntry'. -} + -> m (Maybe ReflogEntry) + {- ^ __Returns:__ the passed in 'GI.Ggit.Structs.ReflogEntry.ReflogEntry' or 'Nothing'. -} +reflogEntryRef reflogEntry = liftIO $ do + reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry + result <- ggit_reflog_entry_ref reflogEntry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed ReflogEntry) result' + return result'' + touchManagedPtr reflogEntry + return maybeResult + +#if ENABLE_OVERLOADING +data ReflogEntryRefMethodInfo +instance (signature ~ (m (Maybe ReflogEntry)), MonadIO m) => O.MethodInfo ReflogEntryRefMethodInfo ReflogEntry signature where + overloadedMethod _ = reflogEntryRef + +#endif + +-- method ReflogEntry::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "reflog_entry", argType = TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflogEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_reflog_entry_unref" ggit_reflog_entry_unref :: + Ptr ReflogEntry -> -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}) + IO () + +{- | +Atomically decrements the reference count of /@reflogEntry@/ by one. +If the reference count drops to 0, /@reflogEntry@/ is freed. +-} +reflogEntryUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + ReflogEntry + {- ^ /@reflogEntry@/: a 'GI.Ggit.Structs.ReflogEntry.ReflogEntry'. -} + -> m () +reflogEntryUnref reflogEntry = liftIO $ do + reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry + ggit_reflog_entry_unref reflogEntry' + touchManagedPtr reflogEntry + return () + +#if ENABLE_OVERLOADING +data ReflogEntryUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ReflogEntryUnrefMethodInfo ReflogEntry signature where + overloadedMethod _ = reflogEntryUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveReflogEntryMethod (t :: Symbol) (o :: *) :: * where + ResolveReflogEntryMethod "ref" o = ReflogEntryRefMethodInfo + ResolveReflogEntryMethod "unref" o = ReflogEntryUnrefMethodInfo + ResolveReflogEntryMethod "getCommitter" o = ReflogEntryGetCommitterMethodInfo + ResolveReflogEntryMethod "getMessage" o = ReflogEntryGetMessageMethodInfo + ResolveReflogEntryMethod "getNewId" o = ReflogEntryGetNewIdMethodInfo + ResolveReflogEntryMethod "getOldId" o = ReflogEntryGetOldIdMethodInfo + ResolveReflogEntryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveReflogEntryMethod t ReflogEntry, O.MethodInfo info ReflogEntry p) => OL.IsLabel t (ReflogEntry -> 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 + + diff --git a/GI/Ggit/Structs/ReflogEntry.hs-boot b/GI/Ggit/Structs/ReflogEntry.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/ReflogEntry.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.ReflogEntry 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 + +newtype ReflogEntry = ReflogEntry (ManagedPtr ReflogEntry) +instance BoxedObject ReflogEntry where +#if ENABLE_OVERLOADING +data ReflogEntryGetCommitterMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogEntryGetMessageMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogEntryGetNewIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogEntryGetOldIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogEntryRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data ReflogEntryUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/RemoteHead.hs b/GI/Ggit/Structs/RemoteHead.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RemoteHead.hs @@ -0,0 +1,347 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git remote head. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.RemoteHead + ( + +-- * Exported types + RemoteHead(..) , + noRemoteHead , + + + -- * Methods +-- ** getLocalOid #method:getLocalOid# + +#if ENABLE_OVERLOADING + RemoteHeadGetLocalOidMethodInfo , +#endif + remoteHeadGetLocalOid , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + RemoteHeadGetNameMethodInfo , +#endif + remoteHeadGetName , + + +-- ** getOid #method:getOid# + +#if ENABLE_OVERLOADING + RemoteHeadGetOidMethodInfo , +#endif + remoteHeadGetOid , + + +-- ** isLocal #method:isLocal# + +#if ENABLE_OVERLOADING + RemoteHeadIsLocalMethodInfo , +#endif + remoteHeadIsLocal , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + RemoteHeadRefMethodInfo , +#endif + remoteHeadRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + RemoteHeadUnrefMethodInfo , +#endif + remoteHeadUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype RemoteHead = RemoteHead (ManagedPtr RemoteHead) +foreign import ccall "ggit_remote_head_get_type" c_ggit_remote_head_get_type :: + IO GType + +instance BoxedObject RemoteHead where + boxedType _ = c_ggit_remote_head_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `RemoteHead`. +noRemoteHead :: Maybe RemoteHead +noRemoteHead = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RemoteHead +type instance O.AttributeList RemoteHead = RemoteHeadAttributeList +type RemoteHeadAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RemoteHead::get_local_oid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote_head", argType = TInterface (Name {namespace = "Ggit", name = "RemoteHead"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemoteHead.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_head_get_local_oid" ggit_remote_head_get_local_oid :: + Ptr RemoteHead -> -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the local oid of the remote head. +-} +remoteHeadGetLocalOid :: + (B.CallStack.HasCallStack, MonadIO m) => + RemoteHead + {- ^ /@remoteHead@/: a 'GI.Ggit.Structs.RemoteHead.RemoteHead'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the local oid or 'Nothing'. -} +remoteHeadGetLocalOid remoteHead = liftIO $ do + remoteHead' <- unsafeManagedPtrGetPtr remoteHead + result <- ggit_remote_head_get_local_oid remoteHead' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr remoteHead + return maybeResult + +#if ENABLE_OVERLOADING +data RemoteHeadGetLocalOidMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo RemoteHeadGetLocalOidMethodInfo RemoteHead signature where + overloadedMethod _ = remoteHeadGetLocalOid + +#endif + +-- method RemoteHead::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote_head", argType = TInterface (Name {namespace = "Ggit", name = "RemoteHead"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemoteHead.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_head_get_name" ggit_remote_head_get_name :: + Ptr RemoteHead -> -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"}) + IO CString + +{- | +Get the remote head name. +-} +remoteHeadGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + RemoteHead + {- ^ /@remoteHead@/: a 'GI.Ggit.Structs.RemoteHead.RemoteHead'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the remote head name or 'Nothing'. -} +remoteHeadGetName remoteHead = liftIO $ do + remoteHead' <- unsafeManagedPtrGetPtr remoteHead + result <- ggit_remote_head_get_name remoteHead' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr remoteHead + return maybeResult + +#if ENABLE_OVERLOADING +data RemoteHeadGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo RemoteHeadGetNameMethodInfo RemoteHead signature where + overloadedMethod _ = remoteHeadGetName + +#endif + +-- method RemoteHead::get_oid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote_head", argType = TInterface (Name {namespace = "Ggit", name = "RemoteHead"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemoteHead.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_head_get_oid" ggit_remote_head_get_oid :: + Ptr RemoteHead -> -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the remote oid of the remote head. +-} +remoteHeadGetOid :: + (B.CallStack.HasCallStack, MonadIO m) => + RemoteHead + {- ^ /@remoteHead@/: a 'GI.Ggit.Structs.RemoteHead.RemoteHead'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the remote oid or 'Nothing'. -} +remoteHeadGetOid remoteHead = liftIO $ do + remoteHead' <- unsafeManagedPtrGetPtr remoteHead + result <- ggit_remote_head_get_oid remoteHead' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr remoteHead + return maybeResult + +#if ENABLE_OVERLOADING +data RemoteHeadGetOidMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo RemoteHeadGetOidMethodInfo RemoteHead signature where + overloadedMethod _ = remoteHeadGetOid + +#endif + +-- method RemoteHead::is_local +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote_head", argType = TInterface (Name {namespace = "Ggit", name = "RemoteHead"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRemoteHead.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_head_is_local" ggit_remote_head_is_local :: + Ptr RemoteHead -> -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"}) + IO CInt + +{- | +Get whether the remote head is local. +-} +remoteHeadIsLocal :: + (B.CallStack.HasCallStack, MonadIO m) => + RemoteHead + {- ^ /@remoteHead@/: a 'GI.Ggit.Structs.RemoteHead.RemoteHead'. -} + -> m Bool + {- ^ __Returns:__ whether the remote head is local. -} +remoteHeadIsLocal remoteHead = liftIO $ do + remoteHead' <- unsafeManagedPtrGetPtr remoteHead + result <- ggit_remote_head_is_local remoteHead' + let result' = (/= 0) result + touchManagedPtr remoteHead + return result' + +#if ENABLE_OVERLOADING +data RemoteHeadIsLocalMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo RemoteHeadIsLocalMethodInfo RemoteHead signature where + overloadedMethod _ = remoteHeadIsLocal + +#endif + +-- method RemoteHead::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote_head", argType = TInterface (Name {namespace = "Ggit", name = "RemoteHead"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RemoteHead"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_head_ref" ggit_remote_head_ref :: + Ptr RemoteHead -> -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"}) + IO (Ptr RemoteHead) + +{- | +/No description available in the introspection data./ +-} +remoteHeadRef :: + (B.CallStack.HasCallStack, MonadIO m) => + RemoteHead + -> m RemoteHead +remoteHeadRef remoteHead = liftIO $ do + remoteHead' <- unsafeManagedPtrGetPtr remoteHead + result <- ggit_remote_head_ref remoteHead' + checkUnexpectedReturnNULL "remoteHeadRef" result + result' <- (wrapBoxed RemoteHead) result + touchManagedPtr remoteHead + return result' + +#if ENABLE_OVERLOADING +data RemoteHeadRefMethodInfo +instance (signature ~ (m RemoteHead), MonadIO m) => O.MethodInfo RemoteHeadRefMethodInfo RemoteHead signature where + overloadedMethod _ = remoteHeadRef + +#endif + +-- method RemoteHead::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "remote_head", argType = TInterface (Name {namespace = "Ggit", name = "RemoteHead"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_remote_head_unref" ggit_remote_head_unref :: + Ptr RemoteHead -> -- remote_head : TInterface (Name {namespace = "Ggit", name = "RemoteHead"}) + IO () + +{- | +/No description available in the introspection data./ +-} +remoteHeadUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + RemoteHead + -> m () +remoteHeadUnref remoteHead = liftIO $ do + remoteHead' <- unsafeManagedPtrGetPtr remoteHead + ggit_remote_head_unref remoteHead' + touchManagedPtr remoteHead + return () + +#if ENABLE_OVERLOADING +data RemoteHeadUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RemoteHeadUnrefMethodInfo RemoteHead signature where + overloadedMethod _ = remoteHeadUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRemoteHeadMethod (t :: Symbol) (o :: *) :: * where + ResolveRemoteHeadMethod "isLocal" o = RemoteHeadIsLocalMethodInfo + ResolveRemoteHeadMethod "ref" o = RemoteHeadRefMethodInfo + ResolveRemoteHeadMethod "unref" o = RemoteHeadUnrefMethodInfo + ResolveRemoteHeadMethod "getLocalOid" o = RemoteHeadGetLocalOidMethodInfo + ResolveRemoteHeadMethod "getName" o = RemoteHeadGetNameMethodInfo + ResolveRemoteHeadMethod "getOid" o = RemoteHeadGetOidMethodInfo + ResolveRemoteHeadMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRemoteHeadMethod t RemoteHead, O.MethodInfo info RemoteHead p) => OL.IsLabel t (RemoteHead -> 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 + + diff --git a/GI/Ggit/Structs/RemoteHead.hs-boot b/GI/Ggit/Structs/RemoteHead.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RemoteHead.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.RemoteHead 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 + +newtype RemoteHead = RemoteHead (ManagedPtr RemoteHead) +instance BoxedObject RemoteHead where +#if ENABLE_OVERLOADING +data RemoteHeadGetLocalOidMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteHeadGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteHeadGetOidMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteHeadIsLocalMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteHeadRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data RemoteHeadUnrefMethodInfo +#endif diff --git a/GI/Ggit/Structs/RevertOptions.hs b/GI/Ggit/Structs/RevertOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RevertOptions.hs @@ -0,0 +1,229 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when reverting. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.RevertOptions + ( + +-- * Exported types + RevertOptions(..) , + noRevertOptions , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + RevertOptionsCopyMethodInfo , +#endif + revertOptionsCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + RevertOptionsFreeMethodInfo , +#endif + revertOptionsFree , + + +-- ** new #method:new# + + revertOptionsNew , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Objects.CheckoutOptions as Ggit.CheckoutOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.MergeOptions as Ggit.MergeOptions + +-- | Memory-managed wrapper type. +newtype RevertOptions = RevertOptions (ManagedPtr RevertOptions) +foreign import ccall "ggit_revert_options_get_type" c_ggit_revert_options_get_type :: + IO GType + +instance BoxedObject RevertOptions where + boxedType _ = c_ggit_revert_options_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `RevertOptions`. +noRevertOptions :: Maybe RevertOptions +noRevertOptions = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RevertOptions +type instance O.AttributeList RevertOptions = RevertOptionsAttributeList +type RevertOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RevertOptions::new +-- method type : Constructor +-- Args : [Arg {argCName = "mainline", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the mainline.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_options", argType = TInterface (Name {namespace = "Ggit", name = "MergeOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitMergeOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "checkout_options", argType = TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GgitCheckoutOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RevertOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_revert_options_new" ggit_revert_options_new :: + Word32 -> -- mainline : TBasicType TUInt + Ptr Ggit.MergeOptions.MergeOptions -> -- merge_options : TInterface (Name {namespace = "Ggit", name = "MergeOptions"}) + Ptr Ggit.CheckoutOptions.CheckoutOptions -> -- checkout_options : TInterface (Name {namespace = "Ggit", name = "CheckoutOptions"}) + IO (Ptr RevertOptions) + +{- | +Create a new 'GI.Ggit.Structs.RevertOptions.RevertOptions'. Note that the passed in /@mergeOptions@/ and +/@checkoutOptions@/ are copied by this function, and alterations in either +after this call are therefore not reflected in the revert options. + +The /@mainline@/ indicates which parent to use for the revert when reverting +a merge commit. +-} +revertOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.CheckoutOptions.IsCheckoutOptions a) => + Word32 + {- ^ /@mainline@/: the mainline. -} + -> Maybe (Ggit.MergeOptions.MergeOptions) + {- ^ /@mergeOptions@/: a 'GI.Ggit.Structs.MergeOptions.MergeOptions'. -} + -> Maybe (a) + {- ^ /@checkoutOptions@/: a 'GI.Ggit.Objects.CheckoutOptions.CheckoutOptions'. -} + -> m (Maybe RevertOptions) + {- ^ __Returns:__ a 'GI.Ggit.Structs.RevertOptions.RevertOptions' or 'Nothing'. -} +revertOptionsNew mainline mergeOptions checkoutOptions = liftIO $ do + maybeMergeOptions <- case mergeOptions of + Nothing -> return nullPtr + Just jMergeOptions -> do + jMergeOptions' <- unsafeManagedPtrGetPtr jMergeOptions + return jMergeOptions' + maybeCheckoutOptions <- case checkoutOptions of + Nothing -> return nullPtr + Just jCheckoutOptions -> do + jCheckoutOptions' <- unsafeManagedPtrCastPtr jCheckoutOptions + return jCheckoutOptions' + result <- ggit_revert_options_new mainline maybeMergeOptions maybeCheckoutOptions + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed RevertOptions) result' + return result'' + whenJust mergeOptions touchManagedPtr + whenJust checkoutOptions touchManagedPtr + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method RevertOptions::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "revert_options", argType = TInterface (Name {namespace = "Ggit", name = "RevertOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevertOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "RevertOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_revert_options_copy" ggit_revert_options_copy :: + Ptr RevertOptions -> -- revert_options : TInterface (Name {namespace = "Ggit", name = "RevertOptions"}) + IO (Ptr RevertOptions) + +{- | +Copies /@revertOptions@/ into a newly allocated 'GI.Ggit.Structs.RevertOptions.RevertOptions'. +-} +revertOptionsCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + RevertOptions + {- ^ /@revertOptions@/: a 'GI.Ggit.Structs.RevertOptions.RevertOptions'. -} + -> m (Maybe RevertOptions) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.RevertOptions.RevertOptions' or 'Nothing'. -} +revertOptionsCopy revertOptions = liftIO $ do + revertOptions' <- unsafeManagedPtrGetPtr revertOptions + result <- ggit_revert_options_copy revertOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed RevertOptions) result' + return result'' + touchManagedPtr revertOptions + return maybeResult + +#if ENABLE_OVERLOADING +data RevertOptionsCopyMethodInfo +instance (signature ~ (m (Maybe RevertOptions)), MonadIO m) => O.MethodInfo RevertOptionsCopyMethodInfo RevertOptions signature where + overloadedMethod _ = revertOptionsCopy + +#endif + +-- method RevertOptions::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "revert_options", argType = TInterface (Name {namespace = "Ggit", name = "RevertOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitRevertOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_revert_options_free" ggit_revert_options_free :: + Ptr RevertOptions -> -- revert_options : TInterface (Name {namespace = "Ggit", name = "RevertOptions"}) + IO () + +{- | +Frees /@revertOptions@/. +-} +revertOptionsFree :: + (B.CallStack.HasCallStack, MonadIO m) => + RevertOptions + {- ^ /@revertOptions@/: a 'GI.Ggit.Structs.RevertOptions.RevertOptions'. -} + -> m () +revertOptionsFree revertOptions = liftIO $ do + revertOptions' <- unsafeManagedPtrGetPtr revertOptions + ggit_revert_options_free revertOptions' + touchManagedPtr revertOptions + return () + +#if ENABLE_OVERLOADING +data RevertOptionsFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RevertOptionsFreeMethodInfo RevertOptions signature where + overloadedMethod _ = revertOptionsFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRevertOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveRevertOptionsMethod "copy" o = RevertOptionsCopyMethodInfo + ResolveRevertOptionsMethod "free" o = RevertOptionsFreeMethodInfo + ResolveRevertOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRevertOptionsMethod t RevertOptions, O.MethodInfo info RevertOptions p) => OL.IsLabel t (RevertOptions -> 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 + + diff --git a/GI/Ggit/Structs/RevertOptions.hs-boot b/GI/Ggit/Structs/RevertOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/RevertOptions.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.RevertOptions 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 + +newtype RevertOptions = RevertOptions (ManagedPtr RevertOptions) +instance BoxedObject RevertOptions where +#if ENABLE_OVERLOADING +data RevertOptionsCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data RevertOptionsFreeMethodInfo +#endif diff --git a/GI/Ggit/Structs/StatusOptions.hs b/GI/Ggit/Structs/StatusOptions.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/StatusOptions.hs @@ -0,0 +1,220 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents the options used when creating getting file status. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.StatusOptions + ( + +-- * Exported types + StatusOptions(..) , + noStatusOptions , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + StatusOptionsCopyMethodInfo , +#endif + statusOptionsCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + StatusOptionsFreeMethodInfo , +#endif + statusOptionsFree , + + +-- ** new #method:new# + + statusOptionsNew , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Flags as Ggit.Flags + +-- | Memory-managed wrapper type. +newtype StatusOptions = StatusOptions (ManagedPtr StatusOptions) +foreign import ccall "ggit_status_options_get_type" c_ggit_status_options_get_type :: + IO GType + +instance BoxedObject StatusOptions where + boxedType _ = c_ggit_status_options_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `StatusOptions`. +noStatusOptions :: Maybe StatusOptions +noStatusOptions = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList StatusOptions +type instance O.AttributeList StatusOptions = StatusOptionsAttributeList +type StatusOptionsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method StatusOptions::new +-- method type : Constructor +-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "StatusOption"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "status options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show", argType = TInterface (Name {namespace = "Ggit", name = "StatusShow"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "status show options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pathspec", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "which paths to show, defaults to showing all paths.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "StatusOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_status_options_new" ggit_status_options_new :: + CUInt -> -- options : TInterface (Name {namespace = "Ggit", name = "StatusOption"}) + CUInt -> -- show : TInterface (Name {namespace = "Ggit", name = "StatusShow"}) + Ptr CString -> -- pathspec : TCArray True (-1) (-1) (TBasicType TUTF8) + IO (Ptr StatusOptions) + +{- | +Creates a new 'GI.Ggit.Structs.StatusOptions.StatusOptions' for use in @/ggit_repository_stash_foreach/@. +-} +statusOptionsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + [Ggit.Flags.StatusOption] + {- ^ /@options@/: status options. -} + -> Ggit.Enums.StatusShow + {- ^ /@show@/: status show options. -} + -> Maybe ([T.Text]) + {- ^ /@pathspec@/: which paths to show, defaults to showing all paths. -} + -> m StatusOptions + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.StatusOptions.StatusOptions'. -} +statusOptionsNew options show_ pathspec = liftIO $ do + let options' = gflagsToWord options + let show_' = (fromIntegral . fromEnum) show_ + maybePathspec <- case pathspec of + Nothing -> return nullPtr + Just jPathspec -> do + jPathspec' <- packZeroTerminatedUTF8CArray jPathspec + return jPathspec' + result <- ggit_status_options_new options' show_' maybePathspec + checkUnexpectedReturnNULL "statusOptionsNew" result + result' <- (wrapBoxed StatusOptions) result + mapZeroTerminatedCArray freeMem maybePathspec + freeMem maybePathspec + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method StatusOptions::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "status_options", argType = TInterface (Name {namespace = "Ggit", name = "StatusOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitStatusOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "StatusOptions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_status_options_copy" ggit_status_options_copy :: + Ptr StatusOptions -> -- status_options : TInterface (Name {namespace = "Ggit", name = "StatusOptions"}) + IO (Ptr StatusOptions) + +{- | +Copies /@statusOptions@/ into a newly allocated 'GI.Ggit.Structs.StatusOptions.StatusOptions'. +-} +statusOptionsCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + StatusOptions + {- ^ /@statusOptions@/: a 'GI.Ggit.Structs.StatusOptions.StatusOptions'. -} + -> m (Maybe StatusOptions) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.StatusOptions.StatusOptions' or 'Nothing'. -} +statusOptionsCopy statusOptions = liftIO $ do + statusOptions' <- unsafeManagedPtrGetPtr statusOptions + result <- ggit_status_options_copy statusOptions' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed StatusOptions) result' + return result'' + touchManagedPtr statusOptions + return maybeResult + +#if ENABLE_OVERLOADING +data StatusOptionsCopyMethodInfo +instance (signature ~ (m (Maybe StatusOptions)), MonadIO m) => O.MethodInfo StatusOptionsCopyMethodInfo StatusOptions signature where + overloadedMethod _ = statusOptionsCopy + +#endif + +-- method StatusOptions::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "status_options", argType = TInterface (Name {namespace = "Ggit", name = "StatusOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitStatusOptions.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_status_options_free" ggit_status_options_free :: + Ptr StatusOptions -> -- status_options : TInterface (Name {namespace = "Ggit", name = "StatusOptions"}) + IO () + +{- | +Frees /@statusOptions@/. +-} +statusOptionsFree :: + (B.CallStack.HasCallStack, MonadIO m) => + StatusOptions + {- ^ /@statusOptions@/: a 'GI.Ggit.Structs.StatusOptions.StatusOptions'. -} + -> m () +statusOptionsFree statusOptions = liftIO $ do + statusOptions' <- unsafeManagedPtrGetPtr statusOptions + ggit_status_options_free statusOptions' + touchManagedPtr statusOptions + return () + +#if ENABLE_OVERLOADING +data StatusOptionsFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StatusOptionsFreeMethodInfo StatusOptions signature where + overloadedMethod _ = statusOptionsFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveStatusOptionsMethod (t :: Symbol) (o :: *) :: * where + ResolveStatusOptionsMethod "copy" o = StatusOptionsCopyMethodInfo + ResolveStatusOptionsMethod "free" o = StatusOptionsFreeMethodInfo + ResolveStatusOptionsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStatusOptionsMethod t StatusOptions, O.MethodInfo info StatusOptions p) => OL.IsLabel t (StatusOptions -> 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 + + diff --git a/GI/Ggit/Structs/StatusOptions.hs-boot b/GI/Ggit/Structs/StatusOptions.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/StatusOptions.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.StatusOptions 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 + +newtype StatusOptions = StatusOptions (ManagedPtr StatusOptions) +instance BoxedObject StatusOptions where +#if ENABLE_OVERLOADING +data StatusOptionsCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data StatusOptionsFreeMethodInfo +#endif diff --git a/GI/Ggit/Structs/Submodule.hs b/GI/Ggit/Structs/Submodule.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Submodule.hs @@ -0,0 +1,910 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a git submodule. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.Submodule + ( + +-- * Exported types + Submodule(..) , + noSubmodule , + + + -- * Methods +-- ** getFetchRecurse #method:getFetchRecurse# + +#if ENABLE_OVERLOADING + SubmoduleGetFetchRecurseMethodInfo , +#endif + submoduleGetFetchRecurse , + + +-- ** getHeadId #method:getHeadId# + +#if ENABLE_OVERLOADING + SubmoduleGetHeadIdMethodInfo , +#endif + submoduleGetHeadId , + + +-- ** getIgnore #method:getIgnore# + +#if ENABLE_OVERLOADING + SubmoduleGetIgnoreMethodInfo , +#endif + submoduleGetIgnore , + + +-- ** getIndexId #method:getIndexId# + +#if ENABLE_OVERLOADING + SubmoduleGetIndexIdMethodInfo , +#endif + submoduleGetIndexId , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + SubmoduleGetNameMethodInfo , +#endif + submoduleGetName , + + +-- ** getOwner #method:getOwner# + +#if ENABLE_OVERLOADING + SubmoduleGetOwnerMethodInfo , +#endif + submoduleGetOwner , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + SubmoduleGetPathMethodInfo , +#endif + submoduleGetPath , + + +-- ** getUpdate #method:getUpdate# + +#if ENABLE_OVERLOADING + SubmoduleGetUpdateMethodInfo , +#endif + submoduleGetUpdate , + + +-- ** getUrl #method:getUrl# + +#if ENABLE_OVERLOADING + SubmoduleGetUrlMethodInfo , +#endif + submoduleGetUrl , + + +-- ** getWorkdirId #method:getWorkdirId# + +#if ENABLE_OVERLOADING + SubmoduleGetWorkdirIdMethodInfo , +#endif + submoduleGetWorkdirId , + + +-- ** init #method:init# + +#if ENABLE_OVERLOADING + SubmoduleInitMethodInfo , +#endif + submoduleInit , + + +-- ** open #method:open# + +#if ENABLE_OVERLOADING + SubmoduleOpenMethodInfo , +#endif + submoduleOpen , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + SubmoduleRefMethodInfo , +#endif + submoduleRef , + + +-- ** reload #method:reload# + +#if ENABLE_OVERLOADING + SubmoduleReloadMethodInfo , +#endif + submoduleReload , + + +-- ** sync #method:sync# + +#if ENABLE_OVERLOADING + SubmoduleSyncMethodInfo , +#endif + submoduleSync , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + SubmoduleUnrefMethodInfo , +#endif + submoduleUnref , + + +-- ** update #method:update# + +#if ENABLE_OVERLOADING + SubmoduleUpdateMethodInfo , +#endif + submoduleUpdate , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Objects.Repository as Ggit.Repository +import {-# SOURCE #-} qualified GI.Ggit.Objects.SubmoduleUpdateOptions as Ggit.SubmoduleUpdateOptions +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype Submodule = Submodule (ManagedPtr Submodule) +foreign import ccall "ggit_submodule_get_type" c_ggit_submodule_get_type :: + IO GType + +instance BoxedObject Submodule where + boxedType _ = c_ggit_submodule_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Submodule`. +noSubmodule :: Maybe Submodule +noSubmodule = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Submodule +type instance O.AttributeList Submodule = SubmoduleAttributeList +type SubmoduleAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Submodule::get_fetch_recurse +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_fetch_recurse" ggit_submodule_get_fetch_recurse :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO CInt + +{- | +Gets whether to fetch recursively. See see gitmodules(5) fetchRecurseSubmodules. +-} +submoduleGetFetchRecurse :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m Bool + {- ^ __Returns:__ whether or not fetch recursively. -} +submoduleGetFetchRecurse submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_fetch_recurse submodule' + let result' = (/= 0) result + touchManagedPtr submodule + return result' + +#if ENABLE_OVERLOADING +data SubmoduleGetFetchRecurseMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo SubmoduleGetFetchRecurseMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetFetchRecurse + +#endif + +-- method Submodule::get_head_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_head_id" ggit_submodule_get_head_id :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO (Ptr Ggit.OId.OId) + +{- | +/No description available in the introspection data./ +-} +submoduleGetHeadId :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + -> m Ggit.OId.OId +submoduleGetHeadId submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_head_id submodule' + checkUnexpectedReturnNULL "submoduleGetHeadId" result + result' <- (wrapBoxed Ggit.OId.OId) result + touchManagedPtr submodule + return result' + +#if ENABLE_OVERLOADING +data SubmoduleGetHeadIdMethodInfo +instance (signature ~ (m Ggit.OId.OId), MonadIO m) => O.MethodInfo SubmoduleGetHeadIdMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetHeadId + +#endif + +-- method Submodule::get_ignore +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "SubmoduleIgnore"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_ignore" ggit_submodule_get_ignore :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO CInt + +{- | +Gets a 'GI.Ggit.Enums.SubmoduleIgnore'. See see gitmodules(5) ignore. +-} +submoduleGetIgnore :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m Ggit.Enums.SubmoduleIgnore + {- ^ __Returns:__ the 'GI.Ggit.Enums.SubmoduleIgnore'. -} +submoduleGetIgnore submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_ignore submodule' + let result' = (toEnum . fromIntegral) result + touchManagedPtr submodule + return result' + +#if ENABLE_OVERLOADING +data SubmoduleGetIgnoreMethodInfo +instance (signature ~ (m Ggit.Enums.SubmoduleIgnore), MonadIO m) => O.MethodInfo SubmoduleGetIgnoreMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetIgnore + +#endif + +-- method Submodule::get_index_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_index_id" ggit_submodule_get_index_id :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the OID for the submodule in the index or 'Nothing' if there is no index. +-} +submoduleGetIndexId :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the OID for the submodule in the index or 'Nothing'. -} +submoduleGetIndexId submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_index_id submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr submodule + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleGetIndexIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo SubmoduleGetIndexIdMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetIndexId + +#endif + +-- method Submodule::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_name" ggit_submodule_get_name :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO CString + +{- | +Gets the name of the submodule from .gitmodules. +-} +submoduleGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of the submodule from .gitmodules or 'Nothing'. -} +submoduleGetName submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_name submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr submodule + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SubmoduleGetNameMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetName + +#endif + +-- method Submodule::get_owner +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_owner" ggit_submodule_get_owner :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO (Ptr Ggit.Repository.Repository) + +{- | +Gets the containing repository for a submodule. +-} +submoduleGetOwner :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe Ggit.Repository.Repository) + {- ^ __Returns:__ the containing repository for a submodule or 'Nothing'. -} +submoduleGetOwner submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_owner submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Repository.Repository) result' + return result'' + touchManagedPtr submodule + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleGetOwnerMethodInfo +instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m) => O.MethodInfo SubmoduleGetOwnerMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetOwner + +#endif + +-- method Submodule::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_path" ggit_submodule_get_path :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO CString + +{- | +Gets the path to the submodule from the repo working directory. +It is almost always the same as the name. +See 'GI.Ggit.Structs.Submodule.submoduleGetName'. +-} +submoduleGetPath :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the path to the submodule from +the repo working directory or 'Nothing'. -} +submoduleGetPath submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_path submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr submodule + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleGetPathMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SubmoduleGetPathMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetPath + +#endif + +-- method Submodule::get_update +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdate"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_update" ggit_submodule_get_update :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO CUInt + +{- | +Gets a 'GI.Ggit.Enums.SubmoduleUpdate'. See see gitmodules(5) update. +-} +submoduleGetUpdate :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m Ggit.Enums.SubmoduleUpdate + {- ^ __Returns:__ the 'GI.Ggit.Enums.SubmoduleUpdate'. -} +submoduleGetUpdate submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_update submodule' + let result' = (toEnum . fromIntegral) result + touchManagedPtr submodule + return result' + +#if ENABLE_OVERLOADING +data SubmoduleGetUpdateMethodInfo +instance (signature ~ (m Ggit.Enums.SubmoduleUpdate), MonadIO m) => O.MethodInfo SubmoduleGetUpdateMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetUpdate + +#endif + +-- method Submodule::get_url +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_url" ggit_submodule_get_url :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO CString + +{- | +Gets the url for the submodule or 'Nothing' if the submodule has been deleted +but not yet committed. +-} +submoduleGetUrl :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the url for the submodule or 'Nothing'. -} +submoduleGetUrl submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_url submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr submodule + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleGetUrlMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SubmoduleGetUrlMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetUrl + +#endif + +-- method Submodule::get_workdir_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_get_workdir_id" ggit_submodule_get_workdir_id :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO (Ptr Ggit.OId.OId) + +{- | +Gets the OID for the submodule in the current working directory. +Corresponds to looking up \'HEAD\' in the checked out submodule. +If there are pending changes in the index or anything +else, this won\'t notice that. You should call @/ggit_submodule_status()/@ +for a more complete picture about the state of the working directory. +-} +submoduleGetWorkdirId :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ the OID for the submodule in the current working directory or 'Nothing'. -} +submoduleGetWorkdirId submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_get_workdir_id submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr submodule + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleGetWorkdirIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo SubmoduleGetWorkdirIdMethodInfo Submodule signature where + overloadedMethod _ = submoduleGetWorkdirId + +#endif + +-- method Submodule::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overwrite", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "forces existing entries to be updated.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_submodule_init" ggit_submodule_init :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + CInt -> -- overwrite : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO () + +{- | +Just like \"git submodule init\", this copies information about the +submodule into \".git\/config\". You can use the accessor functions +above to alter the in-memory git_submodule object and control what +is written to the config, overriding what is in .gitmodules. +-} +submoduleInit :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> Bool + {- ^ /@overwrite@/: forces existing entries to be updated. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +submoduleInit submodule overwrite = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + let overwrite' = (fromIntegral . fromEnum) overwrite + onException (do + propagateGError $ ggit_submodule_init submodule' overwrite' + touchManagedPtr submodule + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SubmoduleInitMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo SubmoduleInitMethodInfo Submodule signature where + overloadedMethod _ = submoduleInit + +#endif + +-- method Submodule::open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Repository"})) +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_submodule_open" ggit_submodule_open :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Ggit.Repository.Repository) + +{- | +Open the repository for a submodule. Multiple calls to this function +will return distinct 'GI.Ggit.Objects.Repository.Repository' objects. Only submodules which are +checked out in the working directory can be opened. +-} +submoduleOpen :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe Ggit.Repository.Repository) + {- ^ __Returns:__ the opened 'GI.Ggit.Objects.Repository.Repository' or 'Nothing' in case of an + error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +submoduleOpen submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + onException (do + result <- propagateGError $ ggit_submodule_open submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Ggit.Repository.Repository) result' + return result'' + touchManagedPtr submodule + return maybeResult + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SubmoduleOpenMethodInfo +instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m) => O.MethodInfo SubmoduleOpenMethodInfo Submodule signature where + overloadedMethod _ = submoduleOpen + +#endif + +-- method Submodule::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "Submodule"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_ref" ggit_submodule_ref :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO (Ptr Submodule) + +{- | +Atomically increments the reference count of /@submodule@/ by one. +This function is MT-safe and may be called from any thread. +-} +submoduleRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m (Maybe Submodule) + {- ^ __Returns:__ the passed in 'GI.Ggit.Structs.Submodule.Submodule' or 'Nothing'. -} +submoduleRef submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + result <- ggit_submodule_ref submodule' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Submodule) result' + return result'' + touchManagedPtr submodule + return maybeResult + +#if ENABLE_OVERLOADING +data SubmoduleRefMethodInfo +instance (signature ~ (m (Maybe Submodule)), MonadIO m) => O.MethodInfo SubmoduleRefMethodInfo Submodule signature where + overloadedMethod _ = submoduleRef + +#endif + +-- method Submodule::reload +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "force", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "reload even if the data doesn't seem out of date.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_submodule_reload" ggit_submodule_reload :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + CInt -> -- force : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO () + +{- | +Rereads submodule info from config, index, and HEAD. +Call this if you have reason to believe that it has changed. +-} +submoduleReload :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> Bool + {- ^ /@force@/: reload even if the data doesn\'t seem out of date. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +submoduleReload submodule force = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + let force' = (fromIntegral . fromEnum) force + onException (do + propagateGError $ ggit_submodule_reload submodule' force' + touchManagedPtr submodule + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SubmoduleReloadMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo SubmoduleReloadMethodInfo Submodule signature where + overloadedMethod _ = submoduleReload + +#endif + +-- method Submodule::sync +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_submodule_sync" ggit_submodule_sync :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Copies the information about the submodules URL into the checked out +submodule config, acting like \"git submodule sync\". This is useful if +you have altered the URL for the submodule (or it has been altered by a +fetch of upstream changes) and you need to update your local repo. +-} +submoduleSync :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +submoduleSync submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + onException (do + propagateGError $ ggit_submodule_sync submodule' + touchManagedPtr submodule + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SubmoduleSyncMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo SubmoduleSyncMethodInfo Submodule signature where + overloadedMethod _ = submoduleSync + +#endif + +-- method Submodule::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_submodule_unref" ggit_submodule_unref :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + IO () + +{- | +Atomically decrements the reference count of /@submodule@/ by one. +If the reference count drops to 0, /@remote@/ is freed. +-} +submoduleUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> m () +submoduleUnref submodule = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + ggit_submodule_unref submodule' + touchManagedPtr submodule + return () + +#if ENABLE_OVERLOADING +data SubmoduleUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo SubmoduleUnrefMethodInfo Submodule signature where + overloadedMethod _ = submoduleUnref + +#endif + +-- method Submodule::update +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "submodule", argType = TInterface (Name {namespace = "Ggit", name = "Submodule"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmodule.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If the submodule is not initialized, setting this flag to true\n will initialize the submodule before updating. Otherwise, this\n will return an error if attempting to update an uninitialzed\n repository. but setting this to true forces them to be updated.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSubmoduleUpdateOptions object.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : True +-- Skip return : False + +foreign import ccall "ggit_submodule_update" ggit_submodule_update :: + Ptr Submodule -> -- submodule : TInterface (Name {namespace = "Ggit", name = "Submodule"}) + CInt -> -- init : TBasicType TBoolean + Ptr Ggit.SubmoduleUpdateOptions.SubmoduleUpdateOptions -> -- options : TInterface (Name {namespace = "Ggit", name = "SubmoduleUpdateOptions"}) + Ptr (Ptr GError) -> -- error + IO () + +{- | +Update a submodule. This will clone a missing submodule and checkout +the subrepository to the commit specified in the index of the containing +repository. If the submodule repository doesn\'t contain the target commit +(e.g. because fetchRecurseSubmodules isn\'t set), then the submodule is +fetched using the fetch options supplied in options. +-} +submoduleUpdate :: + (B.CallStack.HasCallStack, MonadIO m, Ggit.SubmoduleUpdateOptions.IsSubmoduleUpdateOptions a) => + Submodule + {- ^ /@submodule@/: a 'GI.Ggit.Structs.Submodule.Submodule'. -} + -> Bool + {- ^ /@init@/: If the submodule is not initialized, setting this flag to true + will initialize the submodule before updating. Otherwise, this + will return an error if attempting to update an uninitialzed + repository. but setting this to true forces them to be updated. -} + -> a + {- ^ /@options@/: a 'GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions' object. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +submoduleUpdate submodule init options = liftIO $ do + submodule' <- unsafeManagedPtrGetPtr submodule + let init' = (fromIntegral . fromEnum) init + options' <- unsafeManagedPtrCastPtr options + onException (do + propagateGError $ ggit_submodule_update submodule' init' options' + touchManagedPtr submodule + touchManagedPtr options + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data SubmoduleUpdateMethodInfo +instance (signature ~ (Bool -> a -> m ()), MonadIO m, Ggit.SubmoduleUpdateOptions.IsSubmoduleUpdateOptions a) => O.MethodInfo SubmoduleUpdateMethodInfo Submodule signature where + overloadedMethod _ = submoduleUpdate + +#endif + +#if ENABLE_OVERLOADING +type family ResolveSubmoduleMethod (t :: Symbol) (o :: *) :: * where + ResolveSubmoduleMethod "init" o = SubmoduleInitMethodInfo + ResolveSubmoduleMethod "open" o = SubmoduleOpenMethodInfo + ResolveSubmoduleMethod "ref" o = SubmoduleRefMethodInfo + ResolveSubmoduleMethod "reload" o = SubmoduleReloadMethodInfo + ResolveSubmoduleMethod "sync" o = SubmoduleSyncMethodInfo + ResolveSubmoduleMethod "unref" o = SubmoduleUnrefMethodInfo + ResolveSubmoduleMethod "update" o = SubmoduleUpdateMethodInfo + ResolveSubmoduleMethod "getFetchRecurse" o = SubmoduleGetFetchRecurseMethodInfo + ResolveSubmoduleMethod "getHeadId" o = SubmoduleGetHeadIdMethodInfo + ResolveSubmoduleMethod "getIgnore" o = SubmoduleGetIgnoreMethodInfo + ResolveSubmoduleMethod "getIndexId" o = SubmoduleGetIndexIdMethodInfo + ResolveSubmoduleMethod "getName" o = SubmoduleGetNameMethodInfo + ResolveSubmoduleMethod "getOwner" o = SubmoduleGetOwnerMethodInfo + ResolveSubmoduleMethod "getPath" o = SubmoduleGetPathMethodInfo + ResolveSubmoduleMethod "getUpdate" o = SubmoduleGetUpdateMethodInfo + ResolveSubmoduleMethod "getUrl" o = SubmoduleGetUrlMethodInfo + ResolveSubmoduleMethod "getWorkdirId" o = SubmoduleGetWorkdirIdMethodInfo + ResolveSubmoduleMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSubmoduleMethod t Submodule, O.MethodInfo info Submodule p) => OL.IsLabel t (Submodule -> 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 + + diff --git a/GI/Ggit/Structs/Submodule.hs-boot b/GI/Ggit/Structs/Submodule.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/Submodule.hs-boot @@ -0,0 +1,77 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.Submodule 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 + +newtype Submodule = Submodule (ManagedPtr Submodule) +instance BoxedObject Submodule where +#if ENABLE_OVERLOADING +data SubmoduleGetFetchRecurseMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetHeadIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetIgnoreMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetIndexIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetOwnerMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetUpdateMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetUrlMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleGetWorkdirIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleInitMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleOpenMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleReloadMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleSyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleUnrefMethodInfo +#endif +#if ENABLE_OVERLOADING +data SubmoduleUpdateMethodInfo +#endif diff --git a/GI/Ggit/Structs/TransferProgress.hs b/GI/Ggit/Structs/TransferProgress.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/TransferProgress.hs @@ -0,0 +1,340 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents transfering progress. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.TransferProgress + ( + +-- * Exported types + TransferProgress(..) , + noTransferProgress , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + TransferProgressCopyMethodInfo , +#endif + transferProgressCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + TransferProgressFreeMethodInfo , +#endif + transferProgressFree , + + +-- ** getIndexedObjects #method:getIndexedObjects# + +#if ENABLE_OVERLOADING + TransferProgressGetIndexedObjectsMethodInfo, +#endif + transferProgressGetIndexedObjects , + + +-- ** getReceivedBytes #method:getReceivedBytes# + +#if ENABLE_OVERLOADING + TransferProgressGetReceivedBytesMethodInfo, +#endif + transferProgressGetReceivedBytes , + + +-- ** getReceivedObjects #method:getReceivedObjects# + +#if ENABLE_OVERLOADING + TransferProgressGetReceivedObjectsMethodInfo, +#endif + transferProgressGetReceivedObjects , + + +-- ** getTotalObjects #method:getTotalObjects# + +#if ENABLE_OVERLOADING + TransferProgressGetTotalObjectsMethodInfo, +#endif + transferProgressGetTotalObjects , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype TransferProgress = TransferProgress (ManagedPtr TransferProgress) +foreign import ccall "ggit_transfer_progress_get_type" c_ggit_transfer_progress_get_type :: + IO GType + +instance BoxedObject TransferProgress where + boxedType _ = c_ggit_transfer_progress_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `TransferProgress`. +noTransferProgress :: Maybe TransferProgress +noTransferProgress = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList TransferProgress +type instance O.AttributeList TransferProgress = TransferProgressAttributeList +type TransferProgressAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method TransferProgress::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "progress", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TransferProgress"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_transfer_progress_copy" ggit_transfer_progress_copy :: + Ptr TransferProgress -> -- progress : TInterface (Name {namespace = "Ggit", name = "TransferProgress"}) + IO (Ptr TransferProgress) + +{- | +Copies /@progress@/ into a newly allocated 'GI.Ggit.Structs.TransferProgress.TransferProgress'. +-} +transferProgressCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + TransferProgress + {- ^ /@progress@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> m (Maybe TransferProgress) + {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.TransferProgress.TransferProgress' or 'Nothing'. -} +transferProgressCopy progress = liftIO $ do + progress' <- unsafeManagedPtrGetPtr progress + result <- ggit_transfer_progress_copy progress' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed TransferProgress) result' + return result'' + touchManagedPtr progress + return maybeResult + +#if ENABLE_OVERLOADING +data TransferProgressCopyMethodInfo +instance (signature ~ (m (Maybe TransferProgress)), MonadIO m) => O.MethodInfo TransferProgressCopyMethodInfo TransferProgress signature where + overloadedMethod _ = transferProgressCopy + +#endif + +-- method TransferProgress::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "progress", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_transfer_progress_free" ggit_transfer_progress_free :: + Ptr TransferProgress -> -- progress : TInterface (Name {namespace = "Ggit", name = "TransferProgress"}) + IO () + +{- | +Frees /@progress@/. +-} +transferProgressFree :: + (B.CallStack.HasCallStack, MonadIO m) => + TransferProgress + {- ^ /@progress@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> m () +transferProgressFree progress = liftIO $ do + progress' <- unsafeManagedPtrGetPtr progress + ggit_transfer_progress_free progress' + touchManagedPtr progress + return () + +#if ENABLE_OVERLOADING +data TransferProgressFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TransferProgressFreeMethodInfo TransferProgress signature where + overloadedMethod _ = transferProgressFree + +#endif + +-- method TransferProgress::get_indexed_objects +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "progress", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_transfer_progress_get_indexed_objects" ggit_transfer_progress_get_indexed_objects :: + Ptr TransferProgress -> -- progress : TInterface (Name {namespace = "Ggit", name = "TransferProgress"}) + IO Word32 + +{- | +Gets the indexed objects of the transfer. +-} +transferProgressGetIndexedObjects :: + (B.CallStack.HasCallStack, MonadIO m) => + TransferProgress + {- ^ /@progress@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> m Word32 + {- ^ __Returns:__ the indexed objects of the transfer. -} +transferProgressGetIndexedObjects progress = liftIO $ do + progress' <- unsafeManagedPtrGetPtr progress + result <- ggit_transfer_progress_get_indexed_objects progress' + touchManagedPtr progress + return result + +#if ENABLE_OVERLOADING +data TransferProgressGetIndexedObjectsMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo TransferProgressGetIndexedObjectsMethodInfo TransferProgress signature where + overloadedMethod _ = transferProgressGetIndexedObjects + +#endif + +-- method TransferProgress::get_received_bytes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "progress", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", 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_transfer_progress_get_received_bytes" ggit_transfer_progress_get_received_bytes :: + Ptr TransferProgress -> -- progress : TInterface (Name {namespace = "Ggit", name = "TransferProgress"}) + IO Word64 + +{- | +Gets the received bytes of the transfer. +-} +transferProgressGetReceivedBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + TransferProgress + {- ^ /@progress@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> m Word64 + {- ^ __Returns:__ the received bytes of the transfer. -} +transferProgressGetReceivedBytes progress = liftIO $ do + progress' <- unsafeManagedPtrGetPtr progress + result <- ggit_transfer_progress_get_received_bytes progress' + touchManagedPtr progress + return result + +#if ENABLE_OVERLOADING +data TransferProgressGetReceivedBytesMethodInfo +instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo TransferProgressGetReceivedBytesMethodInfo TransferProgress signature where + overloadedMethod _ = transferProgressGetReceivedBytes + +#endif + +-- method TransferProgress::get_received_objects +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "progress", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_transfer_progress_get_received_objects" ggit_transfer_progress_get_received_objects :: + Ptr TransferProgress -> -- progress : TInterface (Name {namespace = "Ggit", name = "TransferProgress"}) + IO Word32 + +{- | +Gets the received objects of the transfer. +-} +transferProgressGetReceivedObjects :: + (B.CallStack.HasCallStack, MonadIO m) => + TransferProgress + {- ^ /@progress@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> m Word32 + {- ^ __Returns:__ the received objects of the transfer. -} +transferProgressGetReceivedObjects progress = liftIO $ do + progress' <- unsafeManagedPtrGetPtr progress + result <- ggit_transfer_progress_get_received_objects progress' + touchManagedPtr progress + return result + +#if ENABLE_OVERLOADING +data TransferProgressGetReceivedObjectsMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo TransferProgressGetReceivedObjectsMethodInfo TransferProgress signature where + overloadedMethod _ = transferProgressGetReceivedObjects + +#endif + +-- method TransferProgress::get_total_objects +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "progress", argType = TInterface (Name {namespace = "Ggit", name = "TransferProgress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTransferProgress.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_transfer_progress_get_total_objects" ggit_transfer_progress_get_total_objects :: + Ptr TransferProgress -> -- progress : TInterface (Name {namespace = "Ggit", name = "TransferProgress"}) + IO Word32 + +{- | +Gets the total objects of the transfer. +-} +transferProgressGetTotalObjects :: + (B.CallStack.HasCallStack, MonadIO m) => + TransferProgress + {- ^ /@progress@/: a 'GI.Ggit.Structs.TransferProgress.TransferProgress'. -} + -> m Word32 + {- ^ __Returns:__ the total objects of the transfer. -} +transferProgressGetTotalObjects progress = liftIO $ do + progress' <- unsafeManagedPtrGetPtr progress + result <- ggit_transfer_progress_get_total_objects progress' + touchManagedPtr progress + return result + +#if ENABLE_OVERLOADING +data TransferProgressGetTotalObjectsMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo TransferProgressGetTotalObjectsMethodInfo TransferProgress signature where + overloadedMethod _ = transferProgressGetTotalObjects + +#endif + +#if ENABLE_OVERLOADING +type family ResolveTransferProgressMethod (t :: Symbol) (o :: *) :: * where + ResolveTransferProgressMethod "copy" o = TransferProgressCopyMethodInfo + ResolveTransferProgressMethod "free" o = TransferProgressFreeMethodInfo + ResolveTransferProgressMethod "getIndexedObjects" o = TransferProgressGetIndexedObjectsMethodInfo + ResolveTransferProgressMethod "getReceivedBytes" o = TransferProgressGetReceivedBytesMethodInfo + ResolveTransferProgressMethod "getReceivedObjects" o = TransferProgressGetReceivedObjectsMethodInfo + ResolveTransferProgressMethod "getTotalObjects" o = TransferProgressGetTotalObjectsMethodInfo + ResolveTransferProgressMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTransferProgressMethod t TransferProgress, O.MethodInfo info TransferProgress p) => OL.IsLabel t (TransferProgress -> 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 + + diff --git a/GI/Ggit/Structs/TransferProgress.hs-boot b/GI/Ggit/Structs/TransferProgress.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/TransferProgress.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.TransferProgress 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 + +newtype TransferProgress = TransferProgress (ManagedPtr TransferProgress) +instance BoxedObject TransferProgress where +#if ENABLE_OVERLOADING +data TransferProgressCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data TransferProgressFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TransferProgressGetIndexedObjectsMethodInfo +#endif +#if ENABLE_OVERLOADING +data TransferProgressGetReceivedBytesMethodInfo +#endif +#if ENABLE_OVERLOADING +data TransferProgressGetReceivedObjectsMethodInfo +#endif +#if ENABLE_OVERLOADING +data TransferProgressGetTotalObjectsMethodInfo +#endif diff --git a/GI/Ggit/Structs/TreeEntry.hs b/GI/Ggit/Structs/TreeEntry.hs new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/TreeEntry.hs @@ -0,0 +1,352 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents an entry in a tree. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Ggit.Structs.TreeEntry + ( + +-- * Exported types + TreeEntry(..) , + noTreeEntry , + + + -- * Methods +-- ** getFileMode #method:getFileMode# + +#if ENABLE_OVERLOADING + TreeEntryGetFileModeMethodInfo , +#endif + treeEntryGetFileMode , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + TreeEntryGetIdMethodInfo , +#endif + treeEntryGetId , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + TreeEntryGetNameMethodInfo , +#endif + treeEntryGetName , + + +-- ** getObjectType #method:getObjectType# + +#if ENABLE_OVERLOADING + TreeEntryGetObjectTypeMethodInfo , +#endif + treeEntryGetObjectType , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + TreeEntryRefMethodInfo , +#endif + treeEntryRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + TreeEntryUnrefMethodInfo , +#endif + treeEntryUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums +import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId + +-- | Memory-managed wrapper type. +newtype TreeEntry = TreeEntry (ManagedPtr TreeEntry) +foreign import ccall "ggit_tree_entry_get_type" c_ggit_tree_entry_get_type :: + IO GType + +instance BoxedObject TreeEntry where + boxedType _ = c_ggit_tree_entry_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `TreeEntry`. +noTreeEntry :: Maybe TreeEntry +noTreeEntry = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList TreeEntry +type instance O.AttributeList TreeEntry = TreeEntryAttributeList +type TreeEntryAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method TreeEntry::get_file_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "FileMode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_entry_get_file_mode" ggit_tree_entry_get_file_mode :: + Ptr TreeEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"}) + IO CUInt + +{- | +Gets the 'GI.Ggit.Enums.FileMode' of a tree entry. +-} +treeEntryGetFileMode :: + (B.CallStack.HasCallStack, MonadIO m) => + TreeEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -} + -> m Ggit.Enums.FileMode + {- ^ __Returns:__ the 'GI.Ggit.Enums.FileMode' of a tree entry. -} +treeEntryGetFileMode entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_tree_entry_get_file_mode entry' + let result' = (toEnum . fromIntegral) result + touchManagedPtr entry + return result' + +#if ENABLE_OVERLOADING +data TreeEntryGetFileModeMethodInfo +instance (signature ~ (m Ggit.Enums.FileMode), MonadIO m) => O.MethodInfo TreeEntryGetFileModeMethodInfo TreeEntry signature where + overloadedMethod _ = treeEntryGetFileMode + +#endif + +-- method TreeEntry::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "OId"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_entry_get_id" ggit_tree_entry_get_id :: + Ptr TreeEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"}) + IO (Ptr Ggit.OId.OId) + +{- | +Get the 'GI.Ggit.Structs.OId.OId' of the entry. +-} +treeEntryGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + TreeEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -} + -> m (Maybe Ggit.OId.OId) + {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -} +treeEntryGetId entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_tree_entry_get_id entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Ggit.OId.OId) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data TreeEntryGetIdMethodInfo +instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo TreeEntryGetIdMethodInfo TreeEntry signature where + overloadedMethod _ = treeEntryGetId + +#endif + +-- method TreeEntry::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_entry_get_name" ggit_tree_entry_get_name :: + Ptr TreeEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"}) + IO CString + +{- | +Get the name of the tree entry. +-} +treeEntryGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + TreeEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of the tree entry or 'Nothing'. -} +treeEntryGetName entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_tree_entry_get_name entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data TreeEntryGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo TreeEntryGetNameMethodInfo TreeEntry signature where + overloadedMethod _ = treeEntryGetName + +#endif + +-- method TreeEntry::get_object_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_entry_get_object_type" ggit_tree_entry_get_object_type :: + Ptr TreeEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"}) + IO CGType + +{- | +Get the type of the tree entry object. +-} +treeEntryGetObjectType :: + (B.CallStack.HasCallStack, MonadIO m) => + TreeEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -} + -> m GType + {- ^ __Returns:__ a 'GType'. -} +treeEntryGetObjectType entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_tree_entry_get_object_type entry' + let result' = GType result + touchManagedPtr entry + return result' + +#if ENABLE_OVERLOADING +data TreeEntryGetObjectTypeMethodInfo +instance (signature ~ (m GType), MonadIO m) => O.MethodInfo TreeEntryGetObjectTypeMethodInfo TreeEntry signature where + overloadedMethod _ = treeEntryGetObjectType + +#endif + +-- method TreeEntry::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "TreeEntry"})) +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_entry_ref" ggit_tree_entry_ref :: + Ptr TreeEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"}) + IO (Ptr TreeEntry) + +{- | +Atomically increments the reference count of /@entry@/ by one. +This function is MT-safe and may be called from any thread. +-} +treeEntryRef :: + (B.CallStack.HasCallStack, MonadIO m) => + TreeEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -} + -> m (Maybe TreeEntry) + {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. -} +treeEntryRef entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + result <- ggit_tree_entry_ref entry' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed TreeEntry) result' + return result'' + touchManagedPtr entry + return maybeResult + +#if ENABLE_OVERLOADING +data TreeEntryRefMethodInfo +instance (signature ~ (m (Maybe TreeEntry)), MonadIO m) => O.MethodInfo TreeEntryRefMethodInfo TreeEntry signature where + overloadedMethod _ = treeEntryRef + +#endif + +-- method TreeEntry::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "entry", argType = TInterface (Name {namespace = "Ggit", name = "TreeEntry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTreeEntry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "ggit_tree_entry_unref" ggit_tree_entry_unref :: + Ptr TreeEntry -> -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"}) + IO () + +{- | +Atomically decrements the reference count of /@entry@/ by one. +If the reference count drops to 0, /@entry@/ is freed. +-} +treeEntryUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + TreeEntry + {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -} + -> m () +treeEntryUnref entry = liftIO $ do + entry' <- unsafeManagedPtrGetPtr entry + ggit_tree_entry_unref entry' + touchManagedPtr entry + return () + +#if ENABLE_OVERLOADING +data TreeEntryUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TreeEntryUnrefMethodInfo TreeEntry signature where + overloadedMethod _ = treeEntryUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveTreeEntryMethod (t :: Symbol) (o :: *) :: * where + ResolveTreeEntryMethod "ref" o = TreeEntryRefMethodInfo + ResolveTreeEntryMethod "unref" o = TreeEntryUnrefMethodInfo + ResolveTreeEntryMethod "getFileMode" o = TreeEntryGetFileModeMethodInfo + ResolveTreeEntryMethod "getId" o = TreeEntryGetIdMethodInfo + ResolveTreeEntryMethod "getName" o = TreeEntryGetNameMethodInfo + ResolveTreeEntryMethod "getObjectType" o = TreeEntryGetObjectTypeMethodInfo + ResolveTreeEntryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTreeEntryMethod t TreeEntry, O.MethodInfo info TreeEntry p) => OL.IsLabel t (TreeEntry -> 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 + + diff --git a/GI/Ggit/Structs/TreeEntry.hs-boot b/GI/Ggit/Structs/TreeEntry.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Ggit/Structs/TreeEntry.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Ggit.Structs.TreeEntry 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 + +newtype TreeEntry = TreeEntry (ManagedPtr TreeEntry) +instance BoxedObject TreeEntry where +#if ENABLE_OVERLOADING +data TreeEntryGetFileModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeEntryGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeEntryGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeEntryGetObjectTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeEntryRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data TreeEntryUnrefMethodInfo +#endif diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-ggit library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-ggit library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-ggit libraries, or to link their applications against a +user-supplied version of gi-ggit. If you link applications to a modified +version of gi-ggit, then the changes to gi-ggit must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-ggit-1.0.2/docs/GI-Ggit.html](https://hackage.haskell.org/package/gi-ggit-1.0.2/docs/GI-Ggit.html) +[https://hackage.haskell.org/package/gi-ggit-1.0.4/docs/GI-Ggit.html](https://hackage.haskell.org/package/gi-ggit-1.0.4/docs/GI-Ggit.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-ggit.cabal b/gi-ggit.cabal --- a/gi-ggit.cabal +++ b/gi-ggit.cabal @@ -1,33 +1,33 @@ name: gi-ggit -version: 1.0.2 +version: 1.0.4 synopsis: libgit2-glib bindings description: Bindings for libgit2-glib, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi license: LGPL-2.1 license-file: LICENSE author: Will Thompson, Iñaki García Etxebarria and Jonas Platte -maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom -cabal-version: >= 1.24 +cabal-version: 1.24 extra-source-files: README.md ChangeLog.md stack.yaml Ggit.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi == 0.21.* + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: libgit2-glib-1.0 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi == 0.21.*, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-gio == 2.0.*, gi-gobject == 2.0.*, @@ -41,3 +41,79 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.Ggit, + GI.Ggit.Callbacks, + GI.Ggit.Enums, + GI.Ggit.Flags, + GI.Ggit.Functions, + GI.Ggit.Objects, + GI.Ggit.Objects.Blame, + GI.Ggit.Objects.Blob, + GI.Ggit.Objects.BlobOutputStream, + GI.Ggit.Objects.Branch, + GI.Ggit.Objects.CheckoutOptions, + GI.Ggit.Objects.CherryPickOptions, + GI.Ggit.Objects.CloneOptions, + GI.Ggit.Objects.Commit, + GI.Ggit.Objects.CommitParents, + GI.Ggit.Objects.Config, + GI.Ggit.Objects.Cred, + GI.Ggit.Objects.CredPlaintext, + GI.Ggit.Objects.CredSshInteractive, + GI.Ggit.Objects.CredSshKeyFromAgent, + GI.Ggit.Objects.Diff, + GI.Ggit.Objects.DiffFindOptions, + GI.Ggit.Objects.DiffFormatEmailOptions, + GI.Ggit.Objects.DiffOptions, + GI.Ggit.Objects.Index, + GI.Ggit.Objects.Native, + GI.Ggit.Objects.Object, + GI.Ggit.Objects.ObjectFactoryBase, + GI.Ggit.Objects.ProxyOptions, + GI.Ggit.Objects.PushOptions, + GI.Ggit.Objects.Rebase, + GI.Ggit.Objects.Ref, + GI.Ggit.Objects.Remote, + GI.Ggit.Objects.RemoteCallbacks, + GI.Ggit.Objects.Repository, + GI.Ggit.Objects.RevisionWalker, + GI.Ggit.Objects.Signature, + GI.Ggit.Objects.SubmoduleUpdateOptions, + GI.Ggit.Objects.Tag, + GI.Ggit.Objects.Tree, + GI.Ggit.Objects.TreeBuilder, + GI.Ggit.Structs, + GI.Ggit.Structs.AnnotatedCommit, + GI.Ggit.Structs.BlameHunk, + GI.Ggit.Structs.BlameOptions, + GI.Ggit.Structs.BranchEnumerator, + GI.Ggit.Structs.ConfigEntry, + GI.Ggit.Structs.CredSshInteractivePrompt, + GI.Ggit.Structs.DiffBinary, + GI.Ggit.Structs.DiffBinaryFile, + GI.Ggit.Structs.DiffDelta, + GI.Ggit.Structs.DiffFile, + GI.Ggit.Structs.DiffHunk, + GI.Ggit.Structs.DiffLine, + GI.Ggit.Structs.DiffSimilarityMetric, + GI.Ggit.Structs.FetchOptions, + GI.Ggit.Structs.IndexEntries, + GI.Ggit.Structs.IndexEntriesResolveUndo, + GI.Ggit.Structs.IndexEntry, + GI.Ggit.Structs.IndexEntryResolveUndo, + GI.Ggit.Structs.MergeOptions, + GI.Ggit.Structs.Note, + GI.Ggit.Structs.OId, + GI.Ggit.Structs.Patch, + GI.Ggit.Structs.RebaseOperation, + GI.Ggit.Structs.RebaseOptions, + GI.Ggit.Structs.RefSpec, + GI.Ggit.Structs.Reflog, + GI.Ggit.Structs.ReflogEntry, + GI.Ggit.Structs.RemoteHead, + GI.Ggit.Structs.RevertOptions, + GI.Ggit.Structs.StatusOptions, + GI.Ggit.Structs.Submodule, + GI.Ggit.Structs.TransferProgress, + GI.Ggit.Structs.TreeEntry diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7