{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Pango.Objects.Coverage.Coverage' structure represents a map from Unicode characters
-- to t'GI.Pango.Enums.CoverageLevel'. It is an opaque structure with no public fields.

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

module GI.Pango.Objects.Coverage
    (

-- * Exported types
    Coverage(..)                            ,
    IsCoverage                              ,
    toCoverage                              ,
    noCoverage                              ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveCoverageMethod                   ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    CoverageCopyMethodInfo                  ,
#endif
    coverageCopy                            ,


-- ** fromBytes #method:fromBytes#

    coverageFromBytes                       ,


-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    CoverageGetMethodInfo                   ,
#endif
    coverageGet                             ,


-- ** max #method:max#

#if defined(ENABLE_OVERLOADING)
    CoverageMaxMethodInfo                   ,
#endif
    coverageMax                             ,


-- ** new #method:new#

    coverageNew                             ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    CoverageRefMethodInfo                   ,
#endif
    coverageRef                             ,


-- ** set #method:set#

#if defined(ENABLE_OVERLOADING)
    CoverageSetMethodInfo                   ,
#endif
    coverageSet                             ,


-- ** toBytes #method:toBytes#

#if defined(ENABLE_OVERLOADING)
    CoverageToBytesMethodInfo               ,
#endif
    coverageToBytes                         ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    CoverageUnrefMethodInfo                 ,
#endif
    coverageUnref                           ,




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums

-- | Memory-managed wrapper type.
newtype Coverage = Coverage (ManagedPtr Coverage)
    deriving (Eq)
foreign import ccall "pango_coverage_get_type"
    c_pango_coverage_get_type :: IO GType

instance GObject Coverage where
    gobjectType = c_pango_coverage_get_type


-- | Convert 'Coverage' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Coverage where
    toGValue o = do
        gtype <- c_pango_coverage_get_type
        B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)

    fromGValue gv = do
        ptr <- B.GValue.get_object gv :: IO (Ptr Coverage)
        B.ManagedPtr.newObject Coverage ptr



-- | Type class for types which can be safely cast to `Coverage`, for instance with `toCoverage`.
class (GObject o, O.IsDescendantOf Coverage o) => IsCoverage o
instance (GObject o, O.IsDescendantOf Coverage o) => IsCoverage o

instance O.HasParentTypes Coverage
type instance O.ParentTypes Coverage = '[GObject.Object.Object]

-- | Cast to `Coverage`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCoverage :: (MonadIO m, IsCoverage o) => o -> m Coverage
toCoverage = liftIO . unsafeCastTo Coverage

-- | A convenience alias for `Nothing` :: `Maybe` `Coverage`.
noCoverage :: Maybe Coverage
noCoverage = Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveCoverageMethod (t :: Symbol) (o :: *) :: * where
    ResolveCoverageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCoverageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCoverageMethod "copy" o = CoverageCopyMethodInfo
    ResolveCoverageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCoverageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCoverageMethod "get" o = CoverageGetMethodInfo
    ResolveCoverageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCoverageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCoverageMethod "max" o = CoverageMaxMethodInfo
    ResolveCoverageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCoverageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCoverageMethod "ref" o = CoverageRefMethodInfo
    ResolveCoverageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCoverageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCoverageMethod "set" o = CoverageSetMethodInfo
    ResolveCoverageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCoverageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCoverageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCoverageMethod "toBytes" o = CoverageToBytesMethodInfo
    ResolveCoverageMethod "unref" o = CoverageUnrefMethodInfo
    ResolveCoverageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCoverageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCoverageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCoverageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCoverageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCoverageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveCoverageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCoverageMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCoverageMethod t Coverage, O.MethodInfo info Coverage p) => OL.IsLabel t (Coverage -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Coverage
type instance O.AttributeList Coverage = CoverageAttributeList
type CoverageAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Coverage = CoverageSignalList
type CoverageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "pango_coverage_new" pango_coverage_new ::
    IO (Ptr Coverage)

-- | Create a new t'GI.Pango.Objects.Coverage.Coverage'
coverageNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Coverage
    -- ^ __Returns:__ the newly allocated t'GI.Pango.Objects.Coverage.Coverage',
    --               initialized to 'GI.Pango.Enums.CoverageLevelNone'
    --               with a reference count of one, which
    --               should be freed with 'GI.Pango.Objects.Coverage.coverageUnref'.
coverageNew  = liftIO $ do
    result <- pango_coverage_new
    checkUnexpectedReturnNULL "coverageNew" result
    result' <- (wrapObject Coverage) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "pango_coverage_copy" pango_coverage_copy ::
    Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
    IO (Ptr Coverage)

-- | Copy an existing t'GI.Pango.Objects.Coverage.Coverage'. (This function may now be unnecessary
-- since we refcount the structure. File a bug if you use it.)
coverageCopy ::
    (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
    a
    -- ^ /@coverage@/: a t'GI.Pango.Objects.Coverage.Coverage'
    -> m Coverage
    -- ^ __Returns:__ the newly allocated t'GI.Pango.Objects.Coverage.Coverage',
    --               with a reference count of one, which should be freed
    --               with 'GI.Pango.Objects.Coverage.coverageUnref'.
coverageCopy coverage = liftIO $ do
    coverage' <- unsafeManagedPtrCastPtr coverage
    result <- pango_coverage_copy coverage'
    checkUnexpectedReturnNULL "coverageCopy" result
    result' <- (wrapObject Coverage) result
    touchManagedPtr coverage
    return result'

#if defined(ENABLE_OVERLOADING)
data CoverageCopyMethodInfo
instance (signature ~ (m Coverage), MonadIO m, IsCoverage a) => O.MethodInfo CoverageCopyMethodInfo a signature where
    overloadedMethod = coverageCopy

#endif

-- method Coverage::get
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "coverage"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Coverage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PangoCoverage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index to check" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Pango" , name = "CoverageLevel" })
-- throws : False
-- Skip return : False

foreign import ccall "pango_coverage_get" pango_coverage_get ::
    Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
    Int32 ->                                -- index_ : TBasicType TInt
    IO CUInt

-- | Determine whether a particular index is covered by /@coverage@/
coverageGet ::
    (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
    a
    -- ^ /@coverage@/: a t'GI.Pango.Objects.Coverage.Coverage'
    -> Int32
    -- ^ /@index_@/: the index to check
    -> m Pango.Enums.CoverageLevel
    -- ^ __Returns:__ the coverage level of /@coverage@/ for character /@index_@/.
coverageGet coverage index_ = liftIO $ do
    coverage' <- unsafeManagedPtrCastPtr coverage
    result <- pango_coverage_get coverage' index_
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr coverage
    return result'

#if defined(ENABLE_OVERLOADING)
data CoverageGetMethodInfo
instance (signature ~ (Int32 -> m Pango.Enums.CoverageLevel), MonadIO m, IsCoverage a) => O.MethodInfo CoverageGetMethodInfo a signature where
    overloadedMethod = coverageGet

#endif

-- method Coverage::max
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "coverage"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Coverage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PangoCoverage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "other"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Coverage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "another #PangoCoverage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_coverage_max" pango_coverage_max ::
    Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
    Ptr Coverage ->                         -- other : TInterface (Name {namespace = "Pango", name = "Coverage"})
    IO ()

{-# DEPRECATED coverageMax ["(Since version 1.44)","This function does nothing"] #-}
-- | Set the coverage for each index in /@coverage@/ to be the max (better)
-- value of the current coverage for the index and the coverage for
-- the corresponding index in /@other@/.
coverageMax ::
    (B.CallStack.HasCallStack, MonadIO m, IsCoverage a, IsCoverage b) =>
    a
    -- ^ /@coverage@/: a t'GI.Pango.Objects.Coverage.Coverage'
    -> b
    -- ^ /@other@/: another t'GI.Pango.Objects.Coverage.Coverage'
    -> m ()
coverageMax coverage other = liftIO $ do
    coverage' <- unsafeManagedPtrCastPtr coverage
    other' <- unsafeManagedPtrCastPtr other
    pango_coverage_max coverage' other'
    touchManagedPtr coverage
    touchManagedPtr other
    return ()

#if defined(ENABLE_OVERLOADING)
data CoverageMaxMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCoverage a, IsCoverage b) => O.MethodInfo CoverageMaxMethodInfo a signature where
    overloadedMethod = coverageMax

#endif

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

foreign import ccall "pango_coverage_ref" pango_coverage_ref ::
    Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
    IO (Ptr Coverage)

-- | Increase the reference count on the t'GI.Pango.Objects.Coverage.Coverage' by one
coverageRef ::
    (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
    a
    -- ^ /@coverage@/: a t'GI.Pango.Objects.Coverage.Coverage'
    -> m Coverage
    -- ^ __Returns:__ /@coverage@/
coverageRef coverage = liftIO $ do
    coverage' <- unsafeManagedPtrCastPtr coverage
    result <- pango_coverage_ref coverage'
    checkUnexpectedReturnNULL "coverageRef" result
    result' <- (wrapObject Coverage) result
    touchManagedPtr coverage
    return result'

#if defined(ENABLE_OVERLOADING)
data CoverageRefMethodInfo
instance (signature ~ (m Coverage), MonadIO m, IsCoverage a) => O.MethodInfo CoverageRefMethodInfo a signature where
    overloadedMethod = coverageRef

#endif

-- method Coverage::set
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "coverage"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Coverage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PangoCoverage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index to modify"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "level"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "CoverageLevel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new level for @index_"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_coverage_set" pango_coverage_set ::
    Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
    Int32 ->                                -- index_ : TBasicType TInt
    CUInt ->                                -- level : TInterface (Name {namespace = "Pango", name = "CoverageLevel"})
    IO ()

-- | Modify a particular index within /@coverage@/
coverageSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
    a
    -- ^ /@coverage@/: a t'GI.Pango.Objects.Coverage.Coverage'
    -> Int32
    -- ^ /@index_@/: the index to modify
    -> Pango.Enums.CoverageLevel
    -- ^ /@level@/: the new level for /@index_@/
    -> m ()
coverageSet coverage index_ level = liftIO $ do
    coverage' <- unsafeManagedPtrCastPtr coverage
    let level' = (fromIntegral . fromEnum) level
    pango_coverage_set coverage' index_ level'
    touchManagedPtr coverage
    return ()

#if defined(ENABLE_OVERLOADING)
data CoverageSetMethodInfo
instance (signature ~ (Int32 -> Pango.Enums.CoverageLevel -> m ()), MonadIO m, IsCoverage a) => O.MethodInfo CoverageSetMethodInfo a signature where
    overloadedMethod = coverageSet

#endif

-- method Coverage::to_bytes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "coverage"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Coverage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PangoCoverage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bytes"
--           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\n  location to store result (must be freed with g_free())"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "n_bytes"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store size of result"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_bytes"
--              , argType = TBasicType TInt
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "location to store size of result"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_coverage_to_bytes" pango_coverage_to_bytes ::
    Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
    Ptr (Ptr Word8) ->                      -- bytes : TCArray False (-1) 2 (TBasicType TUInt8)
    Ptr Int32 ->                            -- n_bytes : TBasicType TInt
    IO ()

{-# DEPRECATED coverageToBytes ["(Since version 1.44)","This returns 'P.Nothing'"] #-}
-- | Convert a t'GI.Pango.Objects.Coverage.Coverage' structure into a flat binary format
coverageToBytes ::
    (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
    a
    -- ^ /@coverage@/: a t'GI.Pango.Objects.Coverage.Coverage'
    -> m (ByteString)
coverageToBytes coverage = liftIO $ do
    coverage' <- unsafeManagedPtrCastPtr coverage
    bytes <- allocMem :: IO (Ptr (Ptr Word8))
    nBytes <- allocMem :: IO (Ptr Int32)
    pango_coverage_to_bytes coverage' bytes nBytes
    nBytes' <- peek nBytes
    bytes' <- peek bytes
    bytes'' <- (unpackByteStringWithLength nBytes') bytes'
    freeMem bytes'
    touchManagedPtr coverage
    freeMem bytes
    freeMem nBytes
    return bytes''

#if defined(ENABLE_OVERLOADING)
data CoverageToBytesMethodInfo
instance (signature ~ (m (ByteString)), MonadIO m, IsCoverage a) => O.MethodInfo CoverageToBytesMethodInfo a signature where
    overloadedMethod = coverageToBytes

#endif

-- method Coverage::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "coverage"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Coverage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PangoCoverage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_coverage_unref" pango_coverage_unref ::
    Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
    IO ()

-- | Decrease the reference count on the t'GI.Pango.Objects.Coverage.Coverage' by one.
-- If the result is zero, free the coverage and all associated memory.
coverageUnref ::
    (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
    a
    -- ^ /@coverage@/: a t'GI.Pango.Objects.Coverage.Coverage'
    -> m ()
coverageUnref coverage = liftIO $ do
    coverage' <- B.ManagedPtr.disownObject coverage
    pango_coverage_unref coverage'
    touchManagedPtr coverage
    return ()

#if defined(ENABLE_OVERLOADING)
data CoverageUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCoverage a) => O.MethodInfo CoverageUnrefMethodInfo a signature where
    overloadedMethod = coverageUnref

#endif

-- method Coverage::from_bytes
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TCArray False (-1) 1 (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "binary data\n  representing a #PangoCoverage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_bytes"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the size of @bytes in bytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_bytes"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the size of @bytes in bytes"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Coverage" })
-- throws : False
-- Skip return : False

foreign import ccall "pango_coverage_from_bytes" pango_coverage_from_bytes ::
    Ptr Word8 ->                            -- bytes : TCArray False (-1) 1 (TBasicType TUInt8)
    Int32 ->                                -- n_bytes : TBasicType TInt
    IO (Ptr Coverage)

{-# DEPRECATED coverageFromBytes ["(Since version 1.44)","This returns 'P.Nothing'"] #-}
-- | Convert data generated from 'GI.Pango.Objects.Coverage.coverageToBytes' back
-- to a t'GI.Pango.Objects.Coverage.Coverage'
coverageFromBytes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ByteString
    -- ^ /@bytes@/: binary data
    --   representing a t'GI.Pango.Objects.Coverage.Coverage'
    -> m (Maybe Coverage)
    -- ^ __Returns:__ a newly allocated
    --               t'GI.Pango.Objects.Coverage.Coverage', or 'P.Nothing' if the data was invalid.
coverageFromBytes bytes = liftIO $ do
    let nBytes = fromIntegral $ B.length bytes
    bytes' <- packByteString bytes
    result <- pango_coverage_from_bytes bytes' nBytes
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Coverage) result'
        return result''
    freeMem bytes'
    return maybeResult

#if defined(ENABLE_OVERLOADING)
#endif