    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A structure that provides information to the type system which is
    -- used specifically for managing fundamental types.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.GObject.Structs.TypeFundamentalInfo
        (

    -- * Exported types
        TypeFundamentalInfo(..)                 ,
        newZeroTypeFundamentalInfo              ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveTypeFundamentalInfoMethod        ,
    #endif

     -- * Properties

    -- ** typeFlags #attr:typeFlags#
    -- | t'GI.GObject.Flags.TypeFundamentalFlags' describing the characteristics of the fundamental type

        getTypeFundamentalInfoTypeFlags         ,
        setTypeFundamentalInfoTypeFlags         ,
    #if defined(ENABLE_OVERLOADING)
        typeFundamentalInfo_typeFlags           ,
    #endif

        ) 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 Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags

    #else
    import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags

    #endif

    -- | Memory-managed wrapper type.
    newtype TypeFundamentalInfo = TypeFundamentalInfo (SP.ManagedPtr TypeFundamentalInfo)
        deriving (TypeFundamentalInfo -> TypeFundamentalInfo -> Bool
    (TypeFundamentalInfo -> TypeFundamentalInfo -> Bool)
    -> (TypeFundamentalInfo -> TypeFundamentalInfo -> Bool)
    -> Eq TypeFundamentalInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TypeFundamentalInfo -> TypeFundamentalInfo -> Bool
    == :: TypeFundamentalInfo -> TypeFundamentalInfo -> Bool
    $c/= :: TypeFundamentalInfo -> TypeFundamentalInfo -> Bool
    /= :: TypeFundamentalInfo -> TypeFundamentalInfo -> Bool
    Eq)

    instance SP.ManagedPtrNewtype TypeFundamentalInfo where
        toManagedPtr :: TypeFundamentalInfo -> ManagedPtr TypeFundamentalInfo
    toManagedPtr (TypeFundamentalInfo ManagedPtr TypeFundamentalInfo
    p) = ManagedPtr TypeFundamentalInfo
    p

    instance BoxedPtr TypeFundamentalInfo where
        boxedPtrCopy :: TypeFundamentalInfo -> IO TypeFundamentalInfo
    boxedPtrCopy = \TypeFundamentalInfo
    p -> TypeFundamentalInfo
    -> (Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo)
    -> IO TypeFundamentalInfo
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr TypeFundamentalInfo
    p (Int -> Ptr TypeFundamentalInfo -> IO (Ptr TypeFundamentalInfo)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes Int
    4 (Ptr TypeFundamentalInfo -> IO (Ptr TypeFundamentalInfo))
    -> (Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo)
    -> Ptr TypeFundamentalInfo
    -> IO TypeFundamentalInfo
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo)
    -> Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo
    TypeFundamentalInfo)
        boxedPtrFree :: TypeFundamentalInfo -> IO ()
    boxedPtrFree = \TypeFundamentalInfo
    x -> TypeFundamentalInfo -> (Ptr TypeFundamentalInfo -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr TypeFundamentalInfo
    x Ptr TypeFundamentalInfo -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr TypeFundamentalInfo where
        boxedPtrCalloc :: IO (Ptr TypeFundamentalInfo)
    boxedPtrCalloc = Int -> IO (Ptr TypeFundamentalInfo)
    forall a. Int -> IO (Ptr a)
    callocBytes Int
    4

    -- | Construct a t'TypeFundamentalInfo' struct initialized to zero.
    newZeroTypeFundamentalInfo :: MonadIO m => m TypeFundamentalInfo
    newZeroTypeFundamentalInfo :: forall (m :: * -> *). MonadIO m => m TypeFundamentalInfo
    newZeroTypeFundamentalInfo = IO TypeFundamentalInfo -> m TypeFundamentalInfo
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TypeFundamentalInfo -> m TypeFundamentalInfo)
    -> IO TypeFundamentalInfo -> m TypeFundamentalInfo
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr TypeFundamentalInfo)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr TypeFundamentalInfo)
    -> (Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo)
    -> IO TypeFundamentalInfo
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo)
    -> Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo
    TypeFundamentalInfo

    instance tag ~ 'AttrSet => Constructible TypeFundamentalInfo tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo)
    -> [AttrOp TypeFundamentalInfo tag] -> m TypeFundamentalInfo
    new ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo
    _ [AttrOp TypeFundamentalInfo tag]
    attrs = do
            o <- m TypeFundamentalInfo
    forall (m :: * -> *). MonadIO m => m TypeFundamentalInfo
    newZeroTypeFundamentalInfo
            GI.Attributes.set o attrs
            return o

    -- | Get the value of the “@type_flags@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' typeFundamentalInfo #typeFlags
    -- @
    getTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> m [GObject.Flags.TypeFundamentalFlags]
    getTypeFundamentalInfoTypeFlags :: forall (m :: * -> *).
    MonadIO m =>
    TypeFundamentalInfo -> m [TypeFundamentalFlags]
    getTypeFundamentalInfoTypeFlags TypeFundamentalInfo
    s = IO [TypeFundamentalFlags] -> m [TypeFundamentalFlags]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [TypeFundamentalFlags] -> m [TypeFundamentalFlags])
    -> IO [TypeFundamentalFlags] -> m [TypeFundamentalFlags]
    forall a b. (a -> b) -> a -> b
    $ TypeFundamentalInfo
    -> (Ptr TypeFundamentalInfo -> IO [TypeFundamentalFlags])
    -> IO [TypeFundamentalFlags]
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TypeFundamentalInfo
    s ((Ptr TypeFundamentalInfo -> IO [TypeFundamentalFlags])
     -> IO [TypeFundamentalFlags])
    -> (Ptr TypeFundamentalInfo -> IO [TypeFundamentalFlags])
    -> IO [TypeFundamentalFlags]
    forall a b. (a -> b) -> a -> b
    $ \Ptr TypeFundamentalInfo
    ptr -> do
        val <- Ptr CUInt -> IO CUInt
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr TypeFundamentalInfo
    ptr Ptr TypeFundamentalInfo -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO CUInt
        let val' = CUInt -> [TypeFundamentalFlags]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CUInt
    val
        return val'

    -- | Set the value of the “@type_flags@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' typeFundamentalInfo [ #typeFlags 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> [GObject.Flags.TypeFundamentalFlags] -> m ()
    setTypeFundamentalInfoTypeFlags :: forall (m :: * -> *).
    MonadIO m =>
    TypeFundamentalInfo -> [TypeFundamentalFlags] -> m ()
    setTypeFundamentalInfoTypeFlags TypeFundamentalInfo
    s [TypeFundamentalFlags]
    val = 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
    $ TypeFundamentalInfo -> (Ptr TypeFundamentalInfo -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr TypeFundamentalInfo
    s ((Ptr TypeFundamentalInfo -> IO ()) -> IO ())
    -> (Ptr TypeFundamentalInfo -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr TypeFundamentalInfo
    ptr -> do
        let val' :: CUInt
    val' = [TypeFundamentalFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [TypeFundamentalFlags]
    val
        Ptr CUInt -> CUInt -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr TypeFundamentalInfo
    ptr Ptr TypeFundamentalInfo -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (CUInt
    val' :: CUInt)

    #if defined(ENABLE_OVERLOADING)
    data TypeFundamentalInfoTypeFlagsFieldInfo
    instance AttrInfo TypeFundamentalInfoTypeFlagsFieldInfo where
        type AttrBaseTypeConstraint TypeFundamentalInfoTypeFlagsFieldInfo = (~) TypeFundamentalInfo
        type AttrAllowedOps TypeFundamentalInfoTypeFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint TypeFundamentalInfoTypeFlagsFieldInfo = (~) [GObject.Flags.TypeFundamentalFlags]
        type AttrTransferTypeConstraint TypeFundamentalInfoTypeFlagsFieldInfo = (~)[GObject.Flags.TypeFundamentalFlags]
        type AttrTransferType TypeFundamentalInfoTypeFlagsFieldInfo = [GObject.Flags.TypeFundamentalFlags]
        type AttrGetType TypeFundamentalInfoTypeFlagsFieldInfo = [GObject.Flags.TypeFundamentalFlags]
        type AttrLabel TypeFundamentalInfoTypeFlagsFieldInfo = "type_flags"
        type AttrOrigin TypeFundamentalInfoTypeFlagsFieldInfo = TypeFundamentalInfo
        attrGet = getTypeFundamentalInfoTypeFlags
        attrSet = setTypeFundamentalInfoTypeFlags
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.TypeFundamentalInfo.typeFlags"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-TypeFundamentalInfo.html#g:attr:typeFlags"
            })

    typeFundamentalInfo_typeFlags :: AttrLabelProxy "typeFlags"
    typeFundamentalInfo_typeFlags = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList TypeFundamentalInfo
    type instance O.AttributeList TypeFundamentalInfo = TypeFundamentalInfoAttributeList
    type TypeFundamentalInfoAttributeList = ('[ '("typeFlags", TypeFundamentalInfoTypeFlagsFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveTypeFundamentalInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveTypeFundamentalInfoMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveTypeFundamentalInfoMethod t TypeFundamentalInfo, O.OverloadedMethod info TypeFundamentalInfo p) => OL.IsLabel t (TypeFundamentalInfo -> 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 ~ ResolveTypeFundamentalInfoMethod t TypeFundamentalInfo, O.OverloadedMethod info TypeFundamentalInfo p, R.HasField t TypeFundamentalInfo p) => R.HasField t TypeFundamentalInfo p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveTypeFundamentalInfoMethod t TypeFundamentalInfo, O.OverloadedMethodInfo info TypeFundamentalInfo) => OL.IsLabel t (O.MethodProxy info TypeFundamentalInfo) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif