{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Poppler.Structs.AnnotMapping.AnnotMapping' structure represents the location
-- of /@annot@/ on the page

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Poppler.Structs.AnnotMapping
    ( 

-- * Exported types
    AnnotMapping(..)                        ,
    newZeroAnnotMapping                     ,
    noAnnotMapping                          ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveAnnotMappingMethod               ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    AnnotMappingCopyMethodInfo              ,
#endif
    annotMappingCopy                        ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    AnnotMappingFreeMethodInfo              ,
#endif
    annotMappingFree                        ,


-- ** new #method:new#

    annotMappingNew                         ,




 -- * Properties
-- ** annot #attr:annot#
-- | a t'GI.Poppler.Objects.Annot.Annot'

#if defined(ENABLE_OVERLOADING)
    annotMapping_annot                      ,
#endif
    clearAnnotMappingAnnot                  ,
    getAnnotMappingAnnot                    ,
    setAnnotMappingAnnot                    ,


-- ** area #attr:area#
-- | a t'GI.Poppler.Structs.Rectangle.Rectangle' representing an area of the page

#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.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.GI.Base.Signals as B.Signals
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.Poppler.Objects.Annot as Poppler.Annot
import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle

-- | Memory-managed wrapper type.
newtype AnnotMapping = AnnotMapping (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)
foreign import ccall "poppler_annot_mapping_get_type" c_poppler_annot_mapping_get_type :: 
    IO GType

instance BoxedObject AnnotMapping where
    boxedType :: AnnotMapping -> IO GType
boxedType _ = IO GType
c_poppler_annot_mapping_get_type

-- | Convert 'AnnotMapping' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue AnnotMapping where
    toGValue :: AnnotMapping -> IO GValue
toGValue o :: AnnotMapping
o = do
        GType
gtype <- IO GType
c_poppler_annot_mapping_get_type
        AnnotMapping -> (Ptr AnnotMapping -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AnnotMapping
o (GType
-> (GValue -> Ptr AnnotMapping -> IO ())
-> Ptr AnnotMapping
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr AnnotMapping -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO AnnotMapping
fromGValue gv :: GValue
gv = do
        Ptr AnnotMapping
ptr <- GValue -> IO (Ptr AnnotMapping)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr AnnotMapping)
        (ManagedPtr AnnotMapping -> AnnotMapping)
-> Ptr AnnotMapping -> IO AnnotMapping
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr AnnotMapping -> AnnotMapping
AnnotMapping Ptr AnnotMapping
ptr
        
    

-- | Construct a `AnnotMapping` struct initialized to zero.
newZeroAnnotMapping :: MonadIO m => m AnnotMapping
newZeroAnnotMapping :: 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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 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, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AnnotMapping -> AnnotMapping
AnnotMapping

instance tag ~ 'AttrSet => Constructible AnnotMapping tag where
    new :: (ManagedPtr AnnotMapping -> AnnotMapping)
-> [AttrOp AnnotMapping tag] -> m AnnotMapping
new _ attrs :: [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


-- | A convenience alias for `Nothing` :: `Maybe` `AnnotMapping`.
noAnnotMapping :: Maybe AnnotMapping
noAnnotMapping :: Maybe AnnotMapping
noAnnotMapping = Maybe AnnotMapping
forall a. Maybe a
Nothing

-- | Get the value of the “@area@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotMapping #area
-- @
getAnnotMappingArea :: MonadIO m => AnnotMapping -> m Poppler.Rectangle.Rectangle
getAnnotMappingArea :: AnnotMapping -> m Rectangle
getAnnotMappingArea s :: 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 :: 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` 0 :: (Ptr Poppler.Rectangle.Rectangle)
    Rectangle
val' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a.
(HasCallStack, BoxedObject 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

annotMapping_area :: AttrLabelProxy "area"
annotMapping_area = AttrLabelProxy

#endif


-- | Get the value of the “@annot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotMapping #annot
-- @
getAnnotMappingAnnot :: MonadIO m => AnnotMapping -> m (Maybe Poppler.Annot.Annot)
getAnnotMappingAnnot :: AnnotMapping -> m (Maybe Annot)
getAnnotMappingAnnot s :: 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 :: 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` 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
$ \val' :: 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

-- | Set the value of the “@annot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' annotMapping [ #annot 'Data.GI.Base.Attributes.:=' value ]
-- @
setAnnotMappingAnnot :: MonadIO m => AnnotMapping -> Ptr Poppler.Annot.Annot -> m ()
setAnnotMappingAnnot :: AnnotMapping -> Ptr Annot -> m ()
setAnnotMappingAnnot s :: AnnotMapping
s val :: 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 :: 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` 32) (Ptr Annot
val :: Ptr Poppler.Annot.Annot)

-- | Set the value of the “@annot@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #annot
-- @
clearAnnotMappingAnnot :: MonadIO m => AnnotMapping -> m ()
clearAnnotMappingAnnot :: AnnotMapping -> m ()
clearAnnotMappingAnnot s :: 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 :: 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` 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

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

-- method AnnotMapping::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Poppler" , name = "AnnotMapping" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_annot_mapping_new" poppler_annot_mapping_new :: 
    IO (Ptr AnnotMapping)

-- | Creates a new t'GI.Poppler.Structs.AnnotMapping.AnnotMapping'
annotMappingNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m AnnotMapping
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.AnnotMapping.AnnotMapping', use 'GI.Poppler.Structs.AnnotMapping.annotMappingFree' to free it
annotMappingNew :: 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 "annotMappingNew" Ptr AnnotMapping
result
    AnnotMapping
result' <- ((ManagedPtr AnnotMapping -> AnnotMapping)
-> Ptr AnnotMapping -> IO AnnotMapping
forall a.
(HasCallStack, BoxedObject 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

-- method AnnotMapping::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mapping"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "AnnotMapping" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerAnnotMapping to copy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Poppler" , name = "AnnotMapping" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_annot_mapping_copy" poppler_annot_mapping_copy :: 
    Ptr AnnotMapping ->                     -- mapping : TInterface (Name {namespace = "Poppler", name = "AnnotMapping"})
    IO (Ptr AnnotMapping)

-- | Creates a copy of /@mapping@/
annotMappingCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AnnotMapping
    -- ^ /@mapping@/: a t'GI.Poppler.Structs.AnnotMapping.AnnotMapping' to copy
    -> m AnnotMapping
    -- ^ __Returns:__ a new allocated copy of /@mapping@/
annotMappingCopy :: AnnotMapping -> m AnnotMapping
annotMappingCopy mapping :: 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 "annotMappingCopy" Ptr AnnotMapping
result
    AnnotMapping
result' <- ((ManagedPtr AnnotMapping -> AnnotMapping)
-> Ptr AnnotMapping -> IO AnnotMapping
forall a.
(HasCallStack, BoxedObject 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.MethodInfo AnnotMappingCopyMethodInfo AnnotMapping signature where
    overloadedMethod = annotMappingCopy

#endif

-- method AnnotMapping::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "mapping"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "AnnotMapping" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerAnnotMapping"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_annot_mapping_free" poppler_annot_mapping_free :: 
    Ptr AnnotMapping ->                     -- mapping : TInterface (Name {namespace = "Poppler", name = "AnnotMapping"})
    IO ()

-- | Frees the given t'GI.Poppler.Structs.AnnotMapping.AnnotMapping'
annotMappingFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AnnotMapping
    -- ^ /@mapping@/: a t'GI.Poppler.Structs.AnnotMapping.AnnotMapping'
    -> m ()
annotMappingFree :: AnnotMapping -> m ()
annotMappingFree mapping :: 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.MethodInfo AnnotMappingFreeMethodInfo AnnotMapping signature where
    overloadedMethod = 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.MethodInfo 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

#endif