{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.Mailmap
(
Mailmap(..) ,
IsMailmap ,
toMailmap ,
#if defined(ENABLE_OVERLOADING)
ResolveMailmapMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MailmapAddEntryMethodInfo ,
#endif
mailmapAddEntry ,
mailmapNew ,
mailmapNewFromRepository ,
#if defined(ENABLE_OVERLOADING)
MailmapResolveMethodInfo ,
#endif
mailmapResolve ,
#if defined(ENABLE_OVERLOADING)
MailmapResolveSignatureMethodInfo ,
#endif
mailmapResolveSignature ,
) 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.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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.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.Signature as Ggit.Signature
newtype Mailmap = Mailmap (SP.ManagedPtr Mailmap)
deriving (Mailmap -> Mailmap -> Bool
(Mailmap -> Mailmap -> Bool)
-> (Mailmap -> Mailmap -> Bool) -> Eq Mailmap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mailmap -> Mailmap -> Bool
== :: Mailmap -> Mailmap -> Bool
$c/= :: Mailmap -> Mailmap -> Bool
/= :: Mailmap -> Mailmap -> Bool
Eq)
instance SP.ManagedPtrNewtype Mailmap where
toManagedPtr :: Mailmap -> ManagedPtr Mailmap
toManagedPtr (Mailmap ManagedPtr Mailmap
p) = ManagedPtr Mailmap
p
foreign import ccall "ggit_mailmap_get_type"
c_ggit_mailmap_get_type :: IO B.Types.GType
instance B.Types.TypedObject Mailmap where
glibType :: IO GType
glibType = IO GType
c_ggit_mailmap_get_type
instance B.Types.GObject Mailmap
class (SP.GObject o, O.IsDescendantOf Mailmap o) => IsMailmap o
instance (SP.GObject o, O.IsDescendantOf Mailmap o) => IsMailmap o
instance O.HasParentTypes Mailmap
type instance O.ParentTypes Mailmap = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]
toMailmap :: (MIO.MonadIO m, IsMailmap o) => o -> m Mailmap
toMailmap :: forall (m :: * -> *) o. (MonadIO m, IsMailmap o) => o -> m Mailmap
toMailmap = IO Mailmap -> m Mailmap
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Mailmap -> m Mailmap) -> (o -> IO Mailmap) -> o -> m Mailmap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Mailmap -> Mailmap) -> o -> IO Mailmap
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Mailmap -> Mailmap
Mailmap
instance B.GValue.IsGValue (Maybe Mailmap) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_mailmap_get_type
gvalueSet_ :: Ptr GValue -> Maybe Mailmap -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Mailmap
P.Nothing = Ptr GValue -> Ptr Mailmap -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Mailmap
forall a. Ptr a
FP.nullPtr :: FP.Ptr Mailmap)
gvalueSet_ Ptr GValue
gv (P.Just Mailmap
obj) = Mailmap -> (Ptr Mailmap -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Mailmap
obj (Ptr GValue -> Ptr Mailmap -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Mailmap)
gvalueGet_ Ptr GValue
gv = do
Ptr Mailmap
ptr <- Ptr GValue -> IO (Ptr Mailmap)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Mailmap)
if Ptr Mailmap
ptr Ptr Mailmap -> Ptr Mailmap -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Mailmap
forall a. Ptr a
FP.nullPtr
then Mailmap -> Maybe Mailmap
forall a. a -> Maybe a
P.Just (Mailmap -> Maybe Mailmap) -> IO Mailmap -> IO (Maybe Mailmap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Mailmap -> Mailmap) -> Ptr Mailmap -> IO Mailmap
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Mailmap -> Mailmap
Mailmap Ptr Mailmap
ptr
else Maybe Mailmap -> IO (Maybe Mailmap)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Mailmap
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveMailmapMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveMailmapMethod "addEntry" o = MailmapAddEntryMethodInfo
ResolveMailmapMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveMailmapMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveMailmapMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveMailmapMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveMailmapMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveMailmapMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveMailmapMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveMailmapMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveMailmapMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveMailmapMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveMailmapMethod "resolve" o = MailmapResolveMethodInfo
ResolveMailmapMethod "resolveSignature" o = MailmapResolveSignatureMethodInfo
ResolveMailmapMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveMailmapMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveMailmapMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveMailmapMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveMailmapMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveMailmapMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveMailmapMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveMailmapMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveMailmapMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveMailmapMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveMailmapMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveMailmapMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveMailmapMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMailmapMethod t Mailmap, O.OverloadedMethod info Mailmap p) => OL.IsLabel t (Mailmap -> 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 ~ ResolveMailmapMethod t Mailmap, O.OverloadedMethod info Mailmap p, R.HasField t Mailmap p) => R.HasField t Mailmap p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMailmapMethod t Mailmap, O.OverloadedMethodInfo info Mailmap) => OL.IsLabel t (O.MethodProxy info Mailmap) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Mailmap
type instance O.AttributeList Mailmap = MailmapAttributeList
type MailmapAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Mailmap = MailmapSignalList
type MailmapSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "ggit_mailmap_new" ggit_mailmap_new ::
Ptr (Ptr GError) ->
IO (Ptr Mailmap)
mailmapNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m (Maybe Mailmap)
mailmapNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m (Maybe Mailmap)
mailmapNew = IO (Maybe Mailmap) -> m (Maybe Mailmap)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Mailmap) -> m (Maybe Mailmap))
-> IO (Maybe Mailmap) -> m (Maybe Mailmap)
forall a b. (a -> b) -> a -> b
$ do
IO (Maybe Mailmap) -> IO () -> IO (Maybe Mailmap)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Mailmap
result <- (Ptr (Ptr GError) -> IO (Ptr Mailmap)) -> IO (Ptr Mailmap)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Mailmap)) -> IO (Ptr Mailmap))
-> (Ptr (Ptr GError) -> IO (Ptr Mailmap)) -> IO (Ptr Mailmap)
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr GError) -> IO (Ptr Mailmap)
ggit_mailmap_new
Maybe Mailmap
maybeResult <- Ptr Mailmap -> (Ptr Mailmap -> IO Mailmap) -> IO (Maybe Mailmap)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Mailmap
result ((Ptr Mailmap -> IO Mailmap) -> IO (Maybe Mailmap))
-> (Ptr Mailmap -> IO Mailmap) -> IO (Maybe Mailmap)
forall a b. (a -> b) -> a -> b
$ \Ptr Mailmap
result' -> do
Mailmap
result'' <- ((ManagedPtr Mailmap -> Mailmap) -> Ptr Mailmap -> IO Mailmap
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Mailmap -> Mailmap
Mailmap) Ptr Mailmap
result'
Mailmap -> IO Mailmap
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Mailmap
result''
Maybe Mailmap -> IO (Maybe Mailmap)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Mailmap
maybeResult
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_mailmap_new_from_repository" ggit_mailmap_new_from_repository ::
Ptr Ggit.Repository.Repository ->
Ptr (Ptr GError) ->
IO (Ptr Mailmap)
mailmapNewFromRepository ::
(B.CallStack.HasCallStack, MonadIO m, Ggit.Repository.IsRepository a) =>
a
-> m (Maybe Mailmap)
mailmapNewFromRepository :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepository a) =>
a -> m (Maybe Mailmap)
mailmapNewFromRepository a
repository = IO (Maybe Mailmap) -> m (Maybe Mailmap)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Mailmap) -> m (Maybe Mailmap))
-> IO (Maybe Mailmap) -> m (Maybe Mailmap)
forall a b. (a -> b) -> a -> b
$ do
Ptr Repository
repository' <- a -> IO (Ptr Repository)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repository
IO (Maybe Mailmap) -> IO () -> IO (Maybe Mailmap)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Mailmap
result <- (Ptr (Ptr GError) -> IO (Ptr Mailmap)) -> IO (Ptr Mailmap)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Mailmap)) -> IO (Ptr Mailmap))
-> (Ptr (Ptr GError) -> IO (Ptr Mailmap)) -> IO (Ptr Mailmap)
forall a b. (a -> b) -> a -> b
$ Ptr Repository -> Ptr (Ptr GError) -> IO (Ptr Mailmap)
ggit_mailmap_new_from_repository Ptr Repository
repository'
Maybe Mailmap
maybeResult <- Ptr Mailmap -> (Ptr Mailmap -> IO Mailmap) -> IO (Maybe Mailmap)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Mailmap
result ((Ptr Mailmap -> IO Mailmap) -> IO (Maybe Mailmap))
-> (Ptr Mailmap -> IO Mailmap) -> IO (Maybe Mailmap)
forall a b. (a -> b) -> a -> b
$ \Ptr Mailmap
result' -> do
Mailmap
result'' <- ((ManagedPtr Mailmap -> Mailmap) -> Ptr Mailmap -> IO Mailmap
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Mailmap -> Mailmap
Mailmap) Ptr Mailmap
result'
Mailmap -> IO Mailmap
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Mailmap
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repository
Maybe Mailmap -> IO (Maybe Mailmap)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Mailmap
maybeResult
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_mailmap_add_entry" ggit_mailmap_add_entry ::
Ptr Mailmap ->
CString ->
CString ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO ()
mailmapAddEntry ::
(B.CallStack.HasCallStack, MonadIO m, IsMailmap a) =>
a
-> Maybe (T.Text)
-> Maybe (T.Text)
-> Maybe (T.Text)
-> T.Text
-> m ()
mailmapAddEntry :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMailmap a) =>
a -> Maybe Text -> Maybe Text -> Maybe Text -> Text -> m ()
mailmapAddEntry a
mailmap Maybe Text
realName Maybe Text
realEmail Maybe Text
replaceName Text
replaceEmail = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Mailmap
mailmap' <- a -> IO (Ptr Mailmap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
mailmap
Ptr CChar
maybeRealName <- case Maybe Text
realName of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jRealName -> do
Ptr CChar
jRealName' <- Text -> IO (Ptr CChar)
textToCString Text
jRealName
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jRealName'
Ptr CChar
maybeRealEmail <- case Maybe Text
realEmail of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jRealEmail -> do
Ptr CChar
jRealEmail' <- Text -> IO (Ptr CChar)
textToCString Text
jRealEmail
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jRealEmail'
Ptr CChar
maybeReplaceName <- case Maybe Text
replaceName of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jReplaceName -> do
Ptr CChar
jReplaceName' <- Text -> IO (Ptr CChar)
textToCString Text
jReplaceName
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jReplaceName'
Ptr CChar
replaceEmail' <- Text -> IO (Ptr CChar)
textToCString Text
replaceEmail
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 Mailmap
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr (Ptr GError)
-> IO ()
ggit_mailmap_add_entry Ptr Mailmap
mailmap' Ptr CChar
maybeRealName Ptr CChar
maybeRealEmail Ptr CChar
maybeReplaceName Ptr CChar
replaceEmail'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
mailmap
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeRealName
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeRealEmail
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeReplaceName
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
replaceEmail'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeRealName
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeRealEmail
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeReplaceName
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
replaceEmail'
)
#if defined(ENABLE_OVERLOADING)
data MailmapAddEntryMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> T.Text -> m ()), MonadIO m, IsMailmap a) => O.OverloadedMethod MailmapAddEntryMethodInfo a signature where
overloadedMethod = mailmapAddEntry
instance O.OverloadedMethodInfo MailmapAddEntryMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Mailmap.mailmapAddEntry",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.14/docs/GI-Ggit-Objects-Mailmap.html#v:mailmapAddEntry"
})
#endif
foreign import ccall "ggit_mailmap_resolve" ggit_mailmap_resolve ::
Ptr Mailmap ->
Ptr CString ->
Ptr CString ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO ()
mailmapResolve ::
(B.CallStack.HasCallStack, MonadIO m, IsMailmap a) =>
a
-> T.Text
-> T.Text
-> m ((T.Text, T.Text))
mailmapResolve :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMailmap a) =>
a -> Text -> Text -> m (Text, Text)
mailmapResolve a
mailmap Text
replaceName Text
replaceEmail = IO (Text, Text) -> m (Text, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Text) -> m (Text, Text))
-> IO (Text, Text) -> m (Text, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Mailmap
mailmap' <- a -> IO (Ptr Mailmap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
mailmap
Ptr (Ptr CChar)
realName <- IO (Ptr (Ptr CChar))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr CChar)
realEmail <- IO (Ptr (Ptr CChar))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CChar
replaceName' <- Text -> IO (Ptr CChar)
textToCString Text
replaceName
Ptr CChar
replaceEmail' <- Text -> IO (Ptr CChar)
textToCString Text
replaceEmail
IO (Text, Text) -> IO () -> IO (Text, Text)
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 Mailmap
-> Ptr (Ptr CChar)
-> Ptr (Ptr CChar)
-> Ptr CChar
-> Ptr CChar
-> Ptr (Ptr GError)
-> IO ()
ggit_mailmap_resolve Ptr Mailmap
mailmap' Ptr (Ptr CChar)
realName Ptr (Ptr CChar)
realEmail Ptr CChar
replaceName' Ptr CChar
replaceEmail'
Ptr CChar
realName' <- Ptr (Ptr CChar) -> IO (Ptr CChar)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CChar)
realName
Text
realName'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
realName'
Ptr CChar
realEmail' <- Ptr (Ptr CChar) -> IO (Ptr CChar)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CChar)
realEmail
Text
realEmail'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
realEmail'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
mailmap
Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
realName
Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
realEmail
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
replaceName'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
replaceEmail'
(Text, Text) -> IO (Text, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
realName'', Text
realEmail'')
) (do
Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
realName
Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
realEmail
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
replaceName'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
replaceEmail'
)
#if defined(ENABLE_OVERLOADING)
data MailmapResolveMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ((T.Text, T.Text))), MonadIO m, IsMailmap a) => O.OverloadedMethod MailmapResolveMethodInfo a signature where
overloadedMethod = mailmapResolve
instance O.OverloadedMethodInfo MailmapResolveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Mailmap.mailmapResolve",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.14/docs/GI-Ggit-Objects-Mailmap.html#v:mailmapResolve"
})
#endif
foreign import ccall "ggit_mailmap_resolve_signature" ggit_mailmap_resolve_signature ::
Ptr Mailmap ->
Ptr Ggit.Signature.Signature ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.Signature.Signature)
mailmapResolveSignature ::
(B.CallStack.HasCallStack, MonadIO m, IsMailmap a, Ggit.Signature.IsSignature b) =>
a
-> b
-> m (Maybe Ggit.Signature.Signature)
mailmapResolveSignature :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMailmap a, IsSignature b) =>
a -> b -> m (Maybe Signature)
mailmapResolveSignature a
mailmap b
signature = IO (Maybe Signature) -> m (Maybe Signature)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Signature) -> m (Maybe Signature))
-> IO (Maybe Signature) -> m (Maybe Signature)
forall a b. (a -> b) -> a -> b
$ do
Ptr Mailmap
mailmap' <- a -> IO (Ptr Mailmap)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
mailmap
Ptr Signature
signature' <- b -> IO (Ptr Signature)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
signature
IO (Maybe Signature) -> IO () -> IO (Maybe Signature)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Signature
result <- (Ptr (Ptr GError) -> IO (Ptr Signature)) -> IO (Ptr Signature)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Signature)) -> IO (Ptr Signature))
-> (Ptr (Ptr GError) -> IO (Ptr Signature)) -> IO (Ptr Signature)
forall a b. (a -> b) -> a -> b
$ Ptr Mailmap
-> Ptr Signature -> Ptr (Ptr GError) -> IO (Ptr Signature)
ggit_mailmap_resolve_signature Ptr Mailmap
mailmap' Ptr Signature
signature'
Maybe Signature
maybeResult <- Ptr Signature
-> (Ptr Signature -> IO Signature) -> IO (Maybe Signature)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Signature
result ((Ptr Signature -> IO Signature) -> IO (Maybe Signature))
-> (Ptr Signature -> IO Signature) -> IO (Maybe Signature)
forall a b. (a -> b) -> a -> b
$ \Ptr Signature
result' -> do
Signature
result'' <- ((ManagedPtr Signature -> Signature)
-> Ptr Signature -> IO Signature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Signature -> Signature
Ggit.Signature.Signature) Ptr Signature
result'
Signature -> IO Signature
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Signature
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
mailmap
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
signature
Maybe Signature -> IO (Maybe Signature)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Signature
maybeResult
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data MailmapResolveSignatureMethodInfo
instance (signature ~ (b -> m (Maybe Ggit.Signature.Signature)), MonadIO m, IsMailmap a, Ggit.Signature.IsSignature b) => O.OverloadedMethod MailmapResolveSignatureMethodInfo a signature where
overloadedMethod = mailmapResolveSignature
instance O.OverloadedMethodInfo MailmapResolveSignatureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Mailmap.mailmapResolveSignature",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.14/docs/GI-Ggit-Objects-Mailmap.html#v:mailmapResolveSignature"
})
#endif