{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Structs.OId
(
OId(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveOIdMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
OIdCompareMethodInfo ,
#endif
oIdCompare ,
#if defined(ENABLE_OVERLOADING)
OIdCopyMethodInfo ,
#endif
oIdCopy ,
#if defined(ENABLE_OVERLOADING)
OIdEqualMethodInfo ,
#endif
oIdEqual ,
#if defined(ENABLE_OVERLOADING)
OIdFreeMethodInfo ,
#endif
oIdFree ,
#if defined(ENABLE_OVERLOADING)
OIdHasPrefixMethodInfo ,
#endif
oIdHasPrefix ,
#if defined(ENABLE_OVERLOADING)
OIdHashMethodInfo ,
#endif
oIdHash ,
#if defined(ENABLE_OVERLOADING)
OIdIsZeroMethodInfo ,
#endif
oIdIsZero ,
oIdNewFromRaw ,
oIdNewFromString ,
#if defined(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.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
newtype OId = OId (SP.ManagedPtr OId)
deriving (OId -> OId -> Bool
(OId -> OId -> Bool) -> (OId -> OId -> Bool) -> Eq OId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OId -> OId -> Bool
$c/= :: OId -> OId -> Bool
== :: OId -> OId -> Bool
$c== :: OId -> OId -> Bool
Eq)
instance SP.ManagedPtrNewtype OId where
toManagedPtr :: OId -> ManagedPtr OId
toManagedPtr (OId ManagedPtr OId
p) = ManagedPtr OId
p
foreign import ccall "ggit_oid_get_type" c_ggit_oid_get_type ::
IO GType
type instance O.ParentTypes OId = '[]
instance O.HasParentTypes OId
instance B.Types.TypedObject OId where
glibType :: IO GType
glibType = IO GType
c_ggit_oid_get_type
instance B.Types.GBoxed OId
instance B.GValue.IsGValue (Maybe OId) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_oid_get_type
gvalueSet_ :: Ptr GValue -> Maybe OId -> IO ()
gvalueSet_ Ptr GValue
gv Maybe OId
P.Nothing = Ptr GValue -> Ptr OId -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr OId
forall a. Ptr a
FP.nullPtr :: FP.Ptr OId)
gvalueSet_ Ptr GValue
gv (P.Just OId
obj) = OId -> (Ptr OId -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr OId
obj (Ptr GValue -> Ptr OId -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe OId)
gvalueGet_ Ptr GValue
gv = do
Ptr OId
ptr <- Ptr GValue -> IO (Ptr OId)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr OId)
if Ptr OId
ptr Ptr OId -> Ptr OId -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr OId
forall a. Ptr a
FP.nullPtr
then OId -> Maybe OId
forall a. a -> Maybe a
P.Just (OId -> Maybe OId) -> IO OId -> IO (Maybe OId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr OId -> OId
OId Ptr OId
ptr
else Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList OId
type instance O.AttributeList OId = OIdAttributeList
type OIdAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_oid_new_from_raw" ggit_oid_new_from_raw ::
Ptr Word8 ->
IO (Ptr OId)
oIdNewFromRaw ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m (Maybe OId)
oIdNewFromRaw :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m (Maybe OId)
oIdNewFromRaw ByteString
raw = 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 Word8
raw' <- ByteString -> IO (Ptr Word8)
packZeroTerminatedByteString ByteString
raw
Ptr OId
result <- Ptr Word8 -> IO (Ptr OId)
ggit_oid_new_from_raw Ptr Word8
raw'
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
OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
raw'
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_oid_new_from_string" ggit_oid_new_from_string ::
CString ->
IO (Ptr OId)
oIdNewFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe OId)
oIdNewFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe OId)
oIdNewFromString Text
str = 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
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr OId
result <- CString -> IO (Ptr OId)
ggit_oid_new_from_string CString
str'
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
OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_oid_compare" ggit_oid_compare ::
Ptr OId ->
Ptr OId ->
IO Int32
oIdCompare ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> OId
-> m Int32
oIdCompare :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OId -> OId -> m Int32
oIdCompare OId
a OId
b = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr OId
a' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
a
Ptr OId
b' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
b
Int32
result <- Ptr OId -> Ptr OId -> IO Int32
ggit_oid_compare Ptr OId
a' Ptr OId
b'
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
a
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
b
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data OIdCompareMethodInfo
instance (signature ~ (OId -> m Int32), MonadIO m) => O.OverloadedMethod OIdCompareMethodInfo OId signature where
overloadedMethod = oIdCompare
instance O.OverloadedMethodInfo OIdCompareMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdCompare",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdCompare"
}
#endif
foreign import ccall "ggit_oid_copy" ggit_oid_copy ::
Ptr OId ->
IO (Ptr OId)
oIdCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> m (Maybe OId)
oIdCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OId -> m (Maybe OId)
oIdCopy OId
oid = 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 OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
Ptr OId
result <- Ptr OId -> IO (Ptr OId)
ggit_oid_copy Ptr OId
oid'
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
OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
data OIdCopyMethodInfo
instance (signature ~ (m (Maybe OId)), MonadIO m) => O.OverloadedMethod OIdCopyMethodInfo OId signature where
overloadedMethod = oIdCopy
instance O.OverloadedMethodInfo OIdCopyMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdCopy",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdCopy"
}
#endif
foreign import ccall "ggit_oid_equal" ggit_oid_equal ::
Ptr OId ->
Ptr OId ->
IO CInt
oIdEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> OId
-> m Bool
oIdEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OId -> OId -> m Bool
oIdEqual OId
a OId
b = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr OId
a' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
a
Ptr OId
b' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
b
CInt
result <- Ptr OId -> Ptr OId -> IO CInt
ggit_oid_equal Ptr OId
a' Ptr OId
b'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
a
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
b
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data OIdEqualMethodInfo
instance (signature ~ (OId -> m Bool), MonadIO m) => O.OverloadedMethod OIdEqualMethodInfo OId signature where
overloadedMethod = oIdEqual
instance O.OverloadedMethodInfo OIdEqualMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdEqual",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdEqual"
}
#endif
foreign import ccall "ggit_oid_free" ggit_oid_free ::
Ptr OId ->
IO ()
oIdFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> m ()
oIdFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => OId -> m ()
oIdFree OId
oid = 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 OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
Ptr OId -> IO ()
ggit_oid_free Ptr OId
oid'
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data OIdFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod OIdFreeMethodInfo OId signature where
overloadedMethod = oIdFree
instance O.OverloadedMethodInfo OIdFreeMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdFree",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdFree"
}
#endif
foreign import ccall "ggit_oid_has_prefix" ggit_oid_has_prefix ::
Ptr OId ->
CString ->
IO CInt
oIdHasPrefix ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> T.Text
-> m Bool
oIdHasPrefix :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OId -> Text -> m Bool
oIdHasPrefix OId
oid Text
prefix = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
CString
prefix' <- Text -> IO CString
textToCString Text
prefix
CInt
result <- Ptr OId -> CString -> IO CInt
ggit_oid_has_prefix Ptr OId
oid' CString
prefix'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
prefix'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data OIdHasPrefixMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod OIdHasPrefixMethodInfo OId signature where
overloadedMethod = oIdHasPrefix
instance O.OverloadedMethodInfo OIdHasPrefixMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdHasPrefix",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdHasPrefix"
}
#endif
foreign import ccall "ggit_oid_hash" ggit_oid_hash ::
Ptr OId ->
IO Word32
oIdHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> m Word32
oIdHash :: forall (m :: * -> *). (HasCallStack, MonadIO m) => OId -> m Word32
oIdHash OId
oid = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
Word32
result <- Ptr OId -> IO Word32
ggit_oid_hash Ptr OId
oid'
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data OIdHashMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod OIdHashMethodInfo OId signature where
overloadedMethod = oIdHash
instance O.OverloadedMethodInfo OIdHashMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdHash",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdHash"
}
#endif
foreign import ccall "ggit_oid_is_zero" ggit_oid_is_zero ::
Ptr OId ->
IO CInt
oIdIsZero ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> m Bool
oIdIsZero :: forall (m :: * -> *). (HasCallStack, MonadIO m) => OId -> m Bool
oIdIsZero OId
oid = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
CInt
result <- Ptr OId -> IO CInt
ggit_oid_is_zero Ptr OId
oid'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data OIdIsZeroMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod OIdIsZeroMethodInfo OId signature where
overloadedMethod = oIdIsZero
instance O.OverloadedMethodInfo OIdIsZeroMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdIsZero",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdIsZero"
}
#endif
foreign import ccall "ggit_oid_to_string" ggit_oid_to_string ::
Ptr OId ->
IO CString
oIdToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
OId
-> m (Maybe T.Text)
oIdToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
OId -> m (Maybe Text)
oIdToString OId
oid = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
CString
result <- Ptr OId -> IO CString
ggit_oid_to_string Ptr OId
oid'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data OIdToStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod OIdToStringMethodInfo OId signature where
overloadedMethod = oIdToString
instance O.OverloadedMethodInfo OIdToStringMethodInfo OId where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.OId.oIdToString",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-OId.html#v:oIdToString"
}
#endif
#if defined(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.OverloadedMethod info OId p) => OL.IsLabel t (OId -> 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 ~ ResolveOIdMethod t OId, O.OverloadedMethod info OId p, R.HasField t OId p) => R.HasField t OId p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveOIdMethod t OId, O.OverloadedMethodInfo info OId) => OL.IsLabel t (O.MethodProxy info OId) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif