{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.TreeBuilder
(
TreeBuilder(..) ,
IsTreeBuilder ,
toTreeBuilder ,
#if defined(ENABLE_OVERLOADING)
ResolveTreeBuilderMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TreeBuilderClearMethodInfo ,
#endif
treeBuilderClear ,
#if defined(ENABLE_OVERLOADING)
TreeBuilderGetEntryMethodInfo ,
#endif
treeBuilderGetEntry ,
#if defined(ENABLE_OVERLOADING)
TreeBuilderInsertMethodInfo ,
#endif
treeBuilderInsert ,
#if defined(ENABLE_OVERLOADING)
TreeBuilderRemoveMethodInfo ,
#endif
treeBuilderRemove ,
#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import 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
newtype TreeBuilder = TreeBuilder (SP.ManagedPtr TreeBuilder)
deriving (TreeBuilder -> TreeBuilder -> Bool
(TreeBuilder -> TreeBuilder -> Bool)
-> (TreeBuilder -> TreeBuilder -> Bool) -> Eq TreeBuilder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeBuilder -> TreeBuilder -> Bool
$c/= :: TreeBuilder -> TreeBuilder -> Bool
== :: TreeBuilder -> TreeBuilder -> Bool
$c== :: TreeBuilder -> TreeBuilder -> Bool
Eq)
instance SP.ManagedPtrNewtype TreeBuilder where
toManagedPtr :: TreeBuilder -> ManagedPtr TreeBuilder
toManagedPtr (TreeBuilder ManagedPtr TreeBuilder
p) = ManagedPtr TreeBuilder
p
foreign import ccall "ggit_tree_builder_get_type"
c_ggit_tree_builder_get_type :: IO B.Types.GType
instance B.Types.TypedObject TreeBuilder where
glibType :: IO GType
glibType = IO GType
c_ggit_tree_builder_get_type
instance B.Types.GObject TreeBuilder
class (SP.GObject o, O.IsDescendantOf TreeBuilder o) => IsTreeBuilder o
instance (SP.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]
toTreeBuilder :: (MIO.MonadIO m, IsTreeBuilder o) => o -> m TreeBuilder
toTreeBuilder :: forall (m :: * -> *) o.
(MonadIO m, IsTreeBuilder o) =>
o -> m TreeBuilder
toTreeBuilder = IO TreeBuilder -> m TreeBuilder
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TreeBuilder -> m TreeBuilder)
-> (o -> IO TreeBuilder) -> o -> m TreeBuilder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TreeBuilder -> TreeBuilder) -> o -> IO TreeBuilder
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr TreeBuilder -> TreeBuilder
TreeBuilder
instance B.GValue.IsGValue (Maybe TreeBuilder) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_tree_builder_get_type
gvalueSet_ :: Ptr GValue -> Maybe TreeBuilder -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TreeBuilder
P.Nothing = Ptr GValue -> Ptr TreeBuilder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TreeBuilder
forall a. Ptr a
FP.nullPtr :: FP.Ptr TreeBuilder)
gvalueSet_ Ptr GValue
gv (P.Just TreeBuilder
obj) = TreeBuilder -> (Ptr TreeBuilder -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeBuilder
obj (Ptr GValue -> Ptr TreeBuilder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TreeBuilder)
gvalueGet_ Ptr GValue
gv = do
Ptr TreeBuilder
ptr <- Ptr GValue -> IO (Ptr TreeBuilder)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TreeBuilder)
if Ptr TreeBuilder
ptr Ptr TreeBuilder -> Ptr TreeBuilder -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TreeBuilder
forall a. Ptr a
FP.nullPtr
then TreeBuilder -> Maybe TreeBuilder
forall a. a -> Maybe a
P.Just (TreeBuilder -> Maybe TreeBuilder)
-> IO TreeBuilder -> IO (Maybe TreeBuilder)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TreeBuilder -> TreeBuilder)
-> Ptr TreeBuilder -> IO TreeBuilder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TreeBuilder -> TreeBuilder
TreeBuilder Ptr TreeBuilder
ptr
else Maybe TreeBuilder -> IO (Maybe TreeBuilder)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeBuilder
forall a. Maybe a
P.Nothing
#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTreeBuilderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTreeBuilderMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTreeBuilderMethod t TreeBuilder, O.OverloadedMethod info TreeBuilder p) => OL.IsLabel t (TreeBuilder -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTreeBuilderMethod t TreeBuilder, O.OverloadedMethod info TreeBuilder p, R.HasField t TreeBuilder p) => R.HasField t TreeBuilder p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTreeBuilderMethod t TreeBuilder, O.OverloadedMethodInfo info TreeBuilder) => OL.IsLabel t (O.MethodProxy info TreeBuilder) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TreeBuilder
type instance O.AttributeList TreeBuilder = TreeBuilderAttributeList
type TreeBuilderAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TreeBuilder = TreeBuilderSignalList
type TreeBuilderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_tree_builder_clear" ggit_tree_builder_clear ::
Ptr TreeBuilder ->
IO ()
treeBuilderClear ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
a
-> m ()
treeBuilderClear :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeBuilder a) =>
a -> m ()
treeBuilderClear a
builder = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
Ptr TreeBuilder -> IO ()
ggit_tree_builder_clear Ptr TreeBuilder
builder'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeBuilderClearMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeBuilder a) => O.OverloadedMethod TreeBuilderClearMethodInfo a signature where
overloadedMethod = treeBuilderClear
instance O.OverloadedMethodInfo TreeBuilderClearMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.TreeBuilder.treeBuilderClear",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-TreeBuilder.html#v:treeBuilderClear"
}
#endif
foreign import ccall "ggit_tree_builder_get_entry" ggit_tree_builder_get_entry ::
Ptr TreeBuilder ->
CString ->
IO (Ptr Ggit.TreeEntry.TreeEntry)
treeBuilderGetEntry ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
a
-> T.Text
-> m (Maybe Ggit.TreeEntry.TreeEntry)
treeBuilderGetEntry :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeBuilder a) =>
a -> Text -> m (Maybe TreeEntry)
treeBuilderGetEntry a
builder Text
path = IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeEntry) -> m (Maybe TreeEntry))
-> IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
CString
path' <- Text -> IO CString
textToCString Text
path
Ptr TreeEntry
result <- Ptr TreeBuilder -> CString -> IO (Ptr TreeEntry)
ggit_tree_builder_get_entry Ptr TreeBuilder
builder' CString
path'
Maybe TreeEntry
maybeResult <- Ptr TreeEntry
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeEntry
result ((Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry))
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeEntry
result' -> do
TreeEntry
result'' <- ((ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreeEntry -> TreeEntry
Ggit.TreeEntry.TreeEntry) Ptr TreeEntry
result'
TreeEntry -> IO TreeEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TreeEntry
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
Maybe TreeEntry -> IO (Maybe TreeEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeBuilderGetEntryMethodInfo
instance (signature ~ (T.Text -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTreeBuilder a) => O.OverloadedMethod TreeBuilderGetEntryMethodInfo a signature where
overloadedMethod = treeBuilderGetEntry
instance O.OverloadedMethodInfo TreeBuilderGetEntryMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.TreeBuilder.treeBuilderGetEntry",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-TreeBuilder.html#v:treeBuilderGetEntry"
}
#endif
foreign import ccall "ggit_tree_builder_insert" ggit_tree_builder_insert ::
Ptr TreeBuilder ->
CString ->
Ptr Ggit.OId.OId ->
CUInt ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.TreeEntry.TreeEntry)
treeBuilderInsert ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
a
-> T.Text
-> Ggit.OId.OId
-> Ggit.Enums.FileMode
-> m (Maybe Ggit.TreeEntry.TreeEntry)
treeBuilderInsert :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeBuilder a) =>
a -> Text -> OId -> FileMode -> m (Maybe TreeEntry)
treeBuilderInsert a
builder Text
filename OId
oid FileMode
fileMode = IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeEntry) -> m (Maybe TreeEntry))
-> IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
CString
filename' <- Text -> IO CString
textToCString Text
filename
Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
let fileMode' :: CUInt
fileMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (FileMode -> Int) -> FileMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FileMode -> Int
forall a. Enum a => a -> Int
fromEnum) FileMode
fileMode
IO (Maybe TreeEntry) -> IO () -> IO (Maybe TreeEntry)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr TreeEntry
result <- (Ptr (Ptr GError) -> IO (Ptr TreeEntry)) -> IO (Ptr TreeEntry)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr TreeEntry)) -> IO (Ptr TreeEntry))
-> (Ptr (Ptr GError) -> IO (Ptr TreeEntry)) -> IO (Ptr TreeEntry)
forall a b. (a -> b) -> a -> b
$ Ptr TreeBuilder
-> CString
-> Ptr OId
-> CUInt
-> Ptr (Ptr GError)
-> IO (Ptr TreeEntry)
ggit_tree_builder_insert Ptr TreeBuilder
builder' CString
filename' Ptr OId
oid' CUInt
fileMode'
Maybe TreeEntry
maybeResult <- Ptr TreeEntry
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeEntry
result ((Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry))
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeEntry
result' -> do
TreeEntry
result'' <- ((ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreeEntry -> TreeEntry
Ggit.TreeEntry.TreeEntry) Ptr TreeEntry
result'
TreeEntry -> IO TreeEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TreeEntry
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Maybe TreeEntry -> IO (Maybe TreeEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
)
#if defined(ENABLE_OVERLOADING)
data TreeBuilderInsertMethodInfo
instance (signature ~ (T.Text -> Ggit.OId.OId -> Ggit.Enums.FileMode -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTreeBuilder a) => O.OverloadedMethod TreeBuilderInsertMethodInfo a signature where
overloadedMethod = treeBuilderInsert
instance O.OverloadedMethodInfo TreeBuilderInsertMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.TreeBuilder.treeBuilderInsert",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-TreeBuilder.html#v:treeBuilderInsert"
}
#endif
foreign import ccall "ggit_tree_builder_remove" ggit_tree_builder_remove ::
Ptr TreeBuilder ->
CString ->
Ptr (Ptr GError) ->
IO ()
treeBuilderRemove ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
a
-> T.Text
-> m ()
treeBuilderRemove :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeBuilder a) =>
a -> Text -> m ()
treeBuilderRemove a
builder Text
path = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
CString
path' <- Text -> IO CString
textToCString Text
path
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
(Ptr (Ptr GError) -> IO ()) -> IO ()
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO ()) -> IO ())
-> (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr TreeBuilder -> CString -> Ptr (Ptr GError) -> IO ()
ggit_tree_builder_remove Ptr TreeBuilder
builder' CString
path'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
)
#if defined(ENABLE_OVERLOADING)
data TreeBuilderRemoveMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTreeBuilder a) => O.OverloadedMethod TreeBuilderRemoveMethodInfo a signature where
overloadedMethod = treeBuilderRemove
instance O.OverloadedMethodInfo TreeBuilderRemoveMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.TreeBuilder.treeBuilderRemove",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-TreeBuilder.html#v:treeBuilderRemove"
}
#endif
foreign import ccall "ggit_tree_builder_write" ggit_tree_builder_write ::
Ptr TreeBuilder ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.OId.OId)
treeBuilderWrite ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
a
-> m (Maybe Ggit.OId.OId)
treeBuilderWrite :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeBuilder a) =>
a -> m (Maybe OId)
treeBuilderWrite a
builder = IO (Maybe OId) -> m (Maybe OId)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OId) -> m (Maybe OId))
-> IO (Maybe OId) -> m (Maybe OId)
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
IO (Maybe OId) -> IO () -> IO (Maybe OId)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr OId
result <- (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId))
-> (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a b. (a -> b) -> a -> b
$ Ptr TreeBuilder -> Ptr (Ptr GError) -> IO (Ptr OId)
ggit_tree_builder_write Ptr TreeBuilder
builder'
Maybe OId
maybeResult <- Ptr OId -> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OId
result ((Ptr OId -> IO OId) -> IO (Maybe OId))
-> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. (a -> b) -> a -> b
$ \Ptr OId
result' -> do
OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data TreeBuilderWriteMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsTreeBuilder a) => O.OverloadedMethod TreeBuilderWriteMethodInfo a signature where
overloadedMethod = treeBuilderWrite
instance O.OverloadedMethodInfo TreeBuilderWriteMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.TreeBuilder.treeBuilderWrite",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-TreeBuilder.html#v:treeBuilderWrite"
}
#endif