{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Poppler.Structs.AnnotMapping
(
AnnotMapping(..) ,
newZeroAnnotMapping ,
#if defined(ENABLE_OVERLOADING)
ResolveAnnotMappingMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
AnnotMappingCopyMethodInfo ,
#endif
annotMappingCopy ,
#if defined(ENABLE_OVERLOADING)
AnnotMappingFreeMethodInfo ,
#endif
annotMappingFree ,
annotMappingNew ,
#if defined(ENABLE_OVERLOADING)
annotMapping_annot ,
#endif
clearAnnotMappingAnnot ,
getAnnotMappingAnnot ,
setAnnotMappingAnnot ,
#if defined(ENABLE_OVERLOADING)
annotMapping_area ,
#endif
getAnnotMappingArea ,
) 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.Coerce as Coerce
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 {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot
import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle
newtype AnnotMapping = AnnotMapping (SP.ManagedPtr AnnotMapping)
deriving (AnnotMapping -> AnnotMapping -> Bool
(AnnotMapping -> AnnotMapping -> Bool)
-> (AnnotMapping -> AnnotMapping -> Bool) -> Eq AnnotMapping
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotMapping -> AnnotMapping -> Bool
$c/= :: AnnotMapping -> AnnotMapping -> Bool
== :: AnnotMapping -> AnnotMapping -> Bool
$c== :: AnnotMapping -> AnnotMapping -> Bool
Eq)
instance SP.ManagedPtrNewtype AnnotMapping where
toManagedPtr :: AnnotMapping -> ManagedPtr AnnotMapping
toManagedPtr (AnnotMapping ManagedPtr AnnotMapping
p) = ManagedPtr AnnotMapping
p
foreign import ccall "poppler_annot_mapping_get_type" c_poppler_annot_mapping_get_type ::
IO GType
type instance O.ParentTypes AnnotMapping = '[]
instance O.HasParentTypes AnnotMapping
instance B.Types.TypedObject AnnotMapping where
glibType :: IO GType
glibType = IO GType
c_poppler_annot_mapping_get_type
instance B.Types.GBoxed AnnotMapping
instance B.GValue.IsGValue (Maybe AnnotMapping) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_poppler_annot_mapping_get_type
gvalueSet_ :: Ptr GValue -> Maybe AnnotMapping -> IO ()
gvalueSet_ Ptr GValue
gv Maybe AnnotMapping
P.Nothing = Ptr GValue -> Ptr AnnotMapping -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr AnnotMapping
forall a. Ptr a
FP.nullPtr :: FP.Ptr AnnotMapping)
gvalueSet_ Ptr GValue
gv (P.Just AnnotMapping
obj) = AnnotMapping -> (Ptr AnnotMapping -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AnnotMapping
obj (Ptr GValue -> Ptr AnnotMapping -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe AnnotMapping)
gvalueGet_ Ptr GValue
gv = do
Ptr AnnotMapping
ptr <- Ptr GValue -> IO (Ptr AnnotMapping)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr AnnotMapping)
if Ptr AnnotMapping
ptr Ptr AnnotMapping -> Ptr AnnotMapping -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr AnnotMapping
forall a. Ptr a
FP.nullPtr
then AnnotMapping -> Maybe AnnotMapping
forall a. a -> Maybe a
P.Just (AnnotMapping -> Maybe AnnotMapping)
-> IO AnnotMapping -> IO (Maybe AnnotMapping)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr AnnotMapping -> AnnotMapping)
-> Ptr AnnotMapping -> IO AnnotMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr AnnotMapping -> AnnotMapping
AnnotMapping Ptr AnnotMapping
ptr
else Maybe AnnotMapping -> IO (Maybe AnnotMapping)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AnnotMapping
forall a. Maybe a
P.Nothing
newZeroAnnotMapping :: MonadIO m => m AnnotMapping
newZeroAnnotMapping :: forall (m :: * -> *). MonadIO m => m AnnotMapping
newZeroAnnotMapping = IO AnnotMapping -> m AnnotMapping
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AnnotMapping -> m AnnotMapping)
-> IO AnnotMapping -> m AnnotMapping
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr AnnotMapping)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
40 IO (Ptr AnnotMapping)
-> (Ptr AnnotMapping -> IO AnnotMapping) -> IO AnnotMapping
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr AnnotMapping -> AnnotMapping)
-> Ptr AnnotMapping -> IO AnnotMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AnnotMapping -> AnnotMapping
AnnotMapping
instance tag ~ 'AttrSet => Constructible AnnotMapping tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr AnnotMapping -> AnnotMapping)
-> [AttrOp AnnotMapping tag] -> m AnnotMapping
new ManagedPtr AnnotMapping -> AnnotMapping
_ [AttrOp AnnotMapping tag]
attrs = do
AnnotMapping
o <- m AnnotMapping
forall (m :: * -> *). MonadIO m => m AnnotMapping
newZeroAnnotMapping
AnnotMapping -> [AttrOp AnnotMapping 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set AnnotMapping
o [AttrOp AnnotMapping tag]
[AttrOp AnnotMapping 'AttrSet]
attrs
AnnotMapping -> m AnnotMapping
forall (m :: * -> *) a. Monad m => a -> m a
return AnnotMapping
o
getAnnotMappingArea :: MonadIO m => AnnotMapping -> m Poppler.Rectangle.Rectangle
getAnnotMappingArea :: forall (m :: * -> *). MonadIO m => AnnotMapping -> m Rectangle
getAnnotMappingArea AnnotMapping
s = IO Rectangle -> m Rectangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
forall a b. (a -> b) -> a -> b
$ AnnotMapping -> (Ptr AnnotMapping -> IO Rectangle) -> IO Rectangle
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotMapping
s ((Ptr AnnotMapping -> IO Rectangle) -> IO Rectangle)
-> (Ptr AnnotMapping -> IO Rectangle) -> IO Rectangle
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotMapping
ptr -> do
let val :: Ptr Rectangle
val = Ptr AnnotMapping
ptr Ptr AnnotMapping -> Int -> Ptr Rectangle
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Poppler.Rectangle.Rectangle)
Rectangle
val' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Rectangle -> Rectangle
Poppler.Rectangle.Rectangle) Ptr Rectangle
val
Rectangle -> IO Rectangle
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
val'
#if defined(ENABLE_OVERLOADING)
data AnnotMappingAreaFieldInfo
instance AttrInfo AnnotMappingAreaFieldInfo where
type AttrBaseTypeConstraint AnnotMappingAreaFieldInfo = (~) AnnotMapping
type AttrAllowedOps AnnotMappingAreaFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint AnnotMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle)
type AttrTransferTypeConstraint AnnotMappingAreaFieldInfo = (~)(Ptr Poppler.Rectangle.Rectangle)
type AttrTransferType AnnotMappingAreaFieldInfo = (Ptr Poppler.Rectangle.Rectangle)
type AttrGetType AnnotMappingAreaFieldInfo = Poppler.Rectangle.Rectangle
type AttrLabel AnnotMappingAreaFieldInfo = "area"
type AttrOrigin AnnotMappingAreaFieldInfo = AnnotMapping
attrGet = getAnnotMappingArea
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Poppler.Structs.AnnotMapping.area"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-AnnotMapping.html#g:attr:area"
})
annotMapping_area :: AttrLabelProxy "area"
annotMapping_area = AttrLabelProxy
#endif
getAnnotMappingAnnot :: MonadIO m => AnnotMapping -> m (Maybe Poppler.Annot.Annot)
getAnnotMappingAnnot :: forall (m :: * -> *). MonadIO m => AnnotMapping -> m (Maybe Annot)
getAnnotMappingAnnot AnnotMapping
s = IO (Maybe Annot) -> m (Maybe Annot)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Annot) -> m (Maybe Annot))
-> IO (Maybe Annot) -> m (Maybe Annot)
forall a b. (a -> b) -> a -> b
$ AnnotMapping
-> (Ptr AnnotMapping -> IO (Maybe Annot)) -> IO (Maybe Annot)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotMapping
s ((Ptr AnnotMapping -> IO (Maybe Annot)) -> IO (Maybe Annot))
-> (Ptr AnnotMapping -> IO (Maybe Annot)) -> IO (Maybe Annot)
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotMapping
ptr -> do
Ptr Annot
val <- Ptr (Ptr Annot) -> IO (Ptr Annot)
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotMapping
ptr Ptr AnnotMapping -> Int -> Ptr (Ptr Annot)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (Ptr Poppler.Annot.Annot)
Maybe Annot
result <- Ptr Annot -> (Ptr Annot -> IO Annot) -> IO (Maybe Annot)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Annot
val ((Ptr Annot -> IO Annot) -> IO (Maybe Annot))
-> (Ptr Annot -> IO Annot) -> IO (Maybe Annot)
forall a b. (a -> b) -> a -> b
$ \Ptr Annot
val' -> do
Annot
val'' <- ((ManagedPtr Annot -> Annot) -> Ptr Annot -> IO Annot
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Annot -> Annot
Poppler.Annot.Annot) Ptr Annot
val'
Annot -> IO Annot
forall (m :: * -> *) a. Monad m => a -> m a
return Annot
val''
Maybe Annot -> IO (Maybe Annot)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Annot
result
setAnnotMappingAnnot :: MonadIO m => AnnotMapping -> Ptr Poppler.Annot.Annot -> m ()
setAnnotMappingAnnot :: forall (m :: * -> *).
MonadIO m =>
AnnotMapping -> Ptr Annot -> m ()
setAnnotMappingAnnot AnnotMapping
s Ptr Annot
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AnnotMapping -> (Ptr AnnotMapping -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotMapping
s ((Ptr AnnotMapping -> IO ()) -> IO ())
-> (Ptr AnnotMapping -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotMapping
ptr -> do
Ptr (Ptr Annot) -> Ptr Annot -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AnnotMapping
ptr Ptr AnnotMapping -> Int -> Ptr (Ptr Annot)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr Annot
val :: Ptr Poppler.Annot.Annot)
clearAnnotMappingAnnot :: MonadIO m => AnnotMapping -> m ()
clearAnnotMappingAnnot :: forall (m :: * -> *). MonadIO m => AnnotMapping -> m ()
clearAnnotMappingAnnot AnnotMapping
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AnnotMapping -> (Ptr AnnotMapping -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotMapping
s ((Ptr AnnotMapping -> IO ()) -> IO ())
-> (Ptr AnnotMapping -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotMapping
ptr -> do
Ptr (Ptr Annot) -> Ptr Annot -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AnnotMapping
ptr Ptr AnnotMapping -> Int -> Ptr (Ptr Annot)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr Annot
forall a. Ptr a
FP.nullPtr :: Ptr Poppler.Annot.Annot)
#if defined(ENABLE_OVERLOADING)
data AnnotMappingAnnotFieldInfo
instance AttrInfo AnnotMappingAnnotFieldInfo where
type AttrBaseTypeConstraint AnnotMappingAnnotFieldInfo = (~) AnnotMapping
type AttrAllowedOps AnnotMappingAnnotFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AnnotMappingAnnotFieldInfo = (~) (Ptr Poppler.Annot.Annot)
type AttrTransferTypeConstraint AnnotMappingAnnotFieldInfo = (~)(Ptr Poppler.Annot.Annot)
type AttrTransferType AnnotMappingAnnotFieldInfo = (Ptr Poppler.Annot.Annot)
type AttrGetType AnnotMappingAnnotFieldInfo = Maybe Poppler.Annot.Annot
type AttrLabel AnnotMappingAnnotFieldInfo = "annot"
type AttrOrigin AnnotMappingAnnotFieldInfo = AnnotMapping
attrGet = getAnnotMappingAnnot
attrSet = setAnnotMappingAnnot
attrConstruct = undefined
attrClear = clearAnnotMappingAnnot
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Poppler.Structs.AnnotMapping.annot"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-AnnotMapping.html#g:attr:annot"
})
annotMapping_annot :: AttrLabelProxy "annot"
annotMapping_annot = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AnnotMapping
type instance O.AttributeList AnnotMapping = AnnotMappingAttributeList
type AnnotMappingAttributeList = ('[ '("area", AnnotMappingAreaFieldInfo), '("annot", AnnotMappingAnnotFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "poppler_annot_mapping_new" poppler_annot_mapping_new ::
IO (Ptr AnnotMapping)
annotMappingNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m AnnotMapping
annotMappingNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m AnnotMapping
annotMappingNew = IO AnnotMapping -> m AnnotMapping
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AnnotMapping -> m AnnotMapping)
-> IO AnnotMapping -> m AnnotMapping
forall a b. (a -> b) -> a -> b
$ do
Ptr AnnotMapping
result <- IO (Ptr AnnotMapping)
poppler_annot_mapping_new
Text -> Ptr AnnotMapping -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"annotMappingNew" Ptr AnnotMapping
result
AnnotMapping
result' <- ((ManagedPtr AnnotMapping -> AnnotMapping)
-> Ptr AnnotMapping -> IO AnnotMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AnnotMapping -> AnnotMapping
AnnotMapping) Ptr AnnotMapping
result
AnnotMapping -> IO AnnotMapping
forall (m :: * -> *) a. Monad m => a -> m a
return AnnotMapping
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "poppler_annot_mapping_copy" poppler_annot_mapping_copy ::
Ptr AnnotMapping ->
IO (Ptr AnnotMapping)
annotMappingCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
AnnotMapping
-> m AnnotMapping
annotMappingCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AnnotMapping -> m AnnotMapping
annotMappingCopy AnnotMapping
mapping = IO AnnotMapping -> m AnnotMapping
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AnnotMapping -> m AnnotMapping)
-> IO AnnotMapping -> m AnnotMapping
forall a b. (a -> b) -> a -> b
$ do
Ptr AnnotMapping
mapping' <- AnnotMapping -> IO (Ptr AnnotMapping)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AnnotMapping
mapping
Ptr AnnotMapping
result <- Ptr AnnotMapping -> IO (Ptr AnnotMapping)
poppler_annot_mapping_copy Ptr AnnotMapping
mapping'
Text -> Ptr AnnotMapping -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"annotMappingCopy" Ptr AnnotMapping
result
AnnotMapping
result' <- ((ManagedPtr AnnotMapping -> AnnotMapping)
-> Ptr AnnotMapping -> IO AnnotMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AnnotMapping -> AnnotMapping
AnnotMapping) Ptr AnnotMapping
result
AnnotMapping -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AnnotMapping
mapping
AnnotMapping -> IO AnnotMapping
forall (m :: * -> *) a. Monad m => a -> m a
return AnnotMapping
result'
#if defined(ENABLE_OVERLOADING)
data AnnotMappingCopyMethodInfo
instance (signature ~ (m AnnotMapping), MonadIO m) => O.OverloadedMethod AnnotMappingCopyMethodInfo AnnotMapping signature where
overloadedMethod = annotMappingCopy
instance O.OverloadedMethodInfo AnnotMappingCopyMethodInfo AnnotMapping where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Poppler.Structs.AnnotMapping.annotMappingCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-AnnotMapping.html#v:annotMappingCopy"
})
#endif
foreign import ccall "poppler_annot_mapping_free" poppler_annot_mapping_free ::
Ptr AnnotMapping ->
IO ()
annotMappingFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
AnnotMapping
-> m ()
annotMappingFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AnnotMapping -> m ()
annotMappingFree AnnotMapping
mapping = 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 AnnotMapping
mapping' <- AnnotMapping -> IO (Ptr AnnotMapping)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AnnotMapping
mapping
Ptr AnnotMapping -> IO ()
poppler_annot_mapping_free Ptr AnnotMapping
mapping'
AnnotMapping -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AnnotMapping
mapping
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AnnotMappingFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AnnotMappingFreeMethodInfo AnnotMapping signature where
overloadedMethod = annotMappingFree
instance O.OverloadedMethodInfo AnnotMappingFreeMethodInfo AnnotMapping where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Poppler.Structs.AnnotMapping.annotMappingFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-AnnotMapping.html#v:annotMappingFree"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAnnotMappingMethod (t :: Symbol) (o :: *) :: * where
ResolveAnnotMappingMethod "copy" o = AnnotMappingCopyMethodInfo
ResolveAnnotMappingMethod "free" o = AnnotMappingFreeMethodInfo
ResolveAnnotMappingMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAnnotMappingMethod t AnnotMapping, O.OverloadedMethod info AnnotMapping p) => OL.IsLabel t (AnnotMapping -> 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 ~ ResolveAnnotMappingMethod t AnnotMapping, O.OverloadedMethod info AnnotMapping p, R.HasField t AnnotMapping p) => R.HasField t AnnotMapping p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAnnotMappingMethod t AnnotMapping, O.OverloadedMethodInfo info AnnotMapping) => OL.IsLabel t (O.MethodProxy info AnnotMapping) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif