{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The class of a flags type holds information about its
-- possible values.

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

module GI.GObject.Structs.FlagsClass
    ( 

-- * Exported types
    FlagsClass(..)                          ,
    newZeroFlagsClass                       ,
    noFlagsClass                            ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveFlagsClassMethod                 ,
#endif




 -- * Properties
-- ** gTypeClass #attr:gTypeClass#
-- | the parent class

#if defined(ENABLE_OVERLOADING)
    flagsClass_gTypeClass                   ,
#endif
    getFlagsClassGTypeClass                 ,


-- ** mask #attr:mask#
-- | a mask covering all possible values.

#if defined(ENABLE_OVERLOADING)
    flagsClass_mask                         ,
#endif
    getFlagsClassMask                       ,
    setFlagsClassMask                       ,


-- ** nValues #attr:nValues#
-- | the number of possible values.

#if defined(ENABLE_OVERLOADING)
    flagsClass_nValues                      ,
#endif
    getFlagsClassNValues                    ,
    setFlagsClassNValues                    ,


-- ** values #attr:values#
-- | an array of t'GI.GObject.Structs.FlagsValue.FlagsValue' structs describing the
--  individual values.

    clearFlagsClassValues                   ,
#if defined(ENABLE_OVERLOADING)
    flagsClass_values                       ,
#endif
    getFlagsClassValues                     ,
    setFlagsClassValues                     ,




    ) 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.GObject.Structs.FlagsValue as GObject.FlagsValue
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass

-- | Memory-managed wrapper type.
newtype FlagsClass = FlagsClass (ManagedPtr FlagsClass)
    deriving (FlagsClass -> FlagsClass -> Bool
(FlagsClass -> FlagsClass -> Bool)
-> (FlagsClass -> FlagsClass -> Bool) -> Eq FlagsClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlagsClass -> FlagsClass -> Bool
$c/= :: FlagsClass -> FlagsClass -> Bool
== :: FlagsClass -> FlagsClass -> Bool
$c== :: FlagsClass -> FlagsClass -> Bool
Eq)
instance WrappedPtr FlagsClass where
    wrappedPtrCalloc :: IO (Ptr FlagsClass)
wrappedPtrCalloc = Int -> IO (Ptr FlagsClass)
forall a. Int -> IO (Ptr a)
callocBytes 24
    wrappedPtrCopy :: FlagsClass -> IO FlagsClass
wrappedPtrCopy = \p :: FlagsClass
p -> FlagsClass -> (Ptr FlagsClass -> IO FlagsClass) -> IO FlagsClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
p (Int -> Ptr FlagsClass -> IO (Ptr FlagsClass)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 24 (Ptr FlagsClass -> IO (Ptr FlagsClass))
-> (Ptr FlagsClass -> IO FlagsClass)
-> Ptr FlagsClass
-> IO FlagsClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr FlagsClass -> FlagsClass)
-> Ptr FlagsClass -> IO FlagsClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr FlagsClass -> FlagsClass
FlagsClass)
    wrappedPtrFree :: Maybe (GDestroyNotify FlagsClass)
wrappedPtrFree = GDestroyNotify FlagsClass -> Maybe (GDestroyNotify FlagsClass)
forall a. a -> Maybe a
Just GDestroyNotify FlagsClass
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `FlagsClass` struct initialized to zero.
newZeroFlagsClass :: MonadIO m => m FlagsClass
newZeroFlagsClass :: m FlagsClass
newZeroFlagsClass = IO FlagsClass -> m FlagsClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlagsClass -> m FlagsClass) -> IO FlagsClass -> m FlagsClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr FlagsClass)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr FlagsClass)
-> (Ptr FlagsClass -> IO FlagsClass) -> IO FlagsClass
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr FlagsClass -> FlagsClass)
-> Ptr FlagsClass -> IO FlagsClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr FlagsClass -> FlagsClass
FlagsClass

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


-- | A convenience alias for `Nothing` :: `Maybe` `FlagsClass`.
noFlagsClass :: Maybe FlagsClass
noFlagsClass :: Maybe FlagsClass
noFlagsClass = Maybe FlagsClass
forall a. Maybe a
Nothing

-- | Get the value of the “@g_type_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' flagsClass #gTypeClass
-- @
getFlagsClassGTypeClass :: MonadIO m => FlagsClass -> m GObject.TypeClass.TypeClass
getFlagsClassGTypeClass :: FlagsClass -> m TypeClass
getFlagsClassGTypeClass s :: FlagsClass
s = IO TypeClass -> m TypeClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeClass -> m TypeClass) -> IO TypeClass -> m TypeClass
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO TypeClass) -> IO TypeClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO TypeClass) -> IO TypeClass)
-> (Ptr FlagsClass -> IO TypeClass) -> IO TypeClass
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    let val :: Ptr TypeClass
val = Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr TypeClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: (Ptr GObject.TypeClass.TypeClass)
    TypeClass
val' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
val
    TypeClass -> IO TypeClass
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
val'

#if defined(ENABLE_OVERLOADING)
data FlagsClassGTypeClassFieldInfo
instance AttrInfo FlagsClassGTypeClassFieldInfo where
    type AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo = (~) FlagsClass
    type AttrAllowedOps FlagsClassGTypeClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint FlagsClassGTypeClassFieldInfo = (~) (Ptr GObject.TypeClass.TypeClass)
    type AttrTransferTypeConstraint FlagsClassGTypeClassFieldInfo = (~)(Ptr GObject.TypeClass.TypeClass)
    type AttrTransferType FlagsClassGTypeClassFieldInfo = (Ptr GObject.TypeClass.TypeClass)
    type AttrGetType FlagsClassGTypeClassFieldInfo = GObject.TypeClass.TypeClass
    type AttrLabel FlagsClassGTypeClassFieldInfo = "g_type_class"
    type AttrOrigin FlagsClassGTypeClassFieldInfo = FlagsClass
    attrGet = getFlagsClassGTypeClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

flagsClass_gTypeClass :: AttrLabelProxy "gTypeClass"
flagsClass_gTypeClass = AttrLabelProxy

#endif


-- | Get the value of the “@mask@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' flagsClass #mask
-- @
getFlagsClassMask :: MonadIO m => FlagsClass -> m Word32
getFlagsClassMask :: FlagsClass -> m Word32
getFlagsClassMask s :: FlagsClass
s = 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
$ FlagsClass -> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO Word32) -> IO Word32)
-> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@mask@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' flagsClass [ #mask 'Data.GI.Base.Attributes.:=' value ]
-- @
setFlagsClassMask :: MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassMask :: FlagsClass -> Word32 -> m ()
setFlagsClassMask s :: FlagsClass
s val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data FlagsClassMaskFieldInfo
instance AttrInfo FlagsClassMaskFieldInfo where
    type AttrBaseTypeConstraint FlagsClassMaskFieldInfo = (~) FlagsClass
    type AttrAllowedOps FlagsClassMaskFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FlagsClassMaskFieldInfo = (~) Word32
    type AttrTransferTypeConstraint FlagsClassMaskFieldInfo = (~)Word32
    type AttrTransferType FlagsClassMaskFieldInfo = Word32
    type AttrGetType FlagsClassMaskFieldInfo = Word32
    type AttrLabel FlagsClassMaskFieldInfo = "mask"
    type AttrOrigin FlagsClassMaskFieldInfo = FlagsClass
    attrGet = getFlagsClassMask
    attrSet = setFlagsClassMask
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

flagsClass_mask :: AttrLabelProxy "mask"
flagsClass_mask = AttrLabelProxy

#endif


-- | Get the value of the “@n_values@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' flagsClass #nValues
-- @
getFlagsClassNValues :: MonadIO m => FlagsClass -> m Word32
getFlagsClassNValues :: FlagsClass -> m Word32
getFlagsClassNValues s :: FlagsClass
s = 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
$ FlagsClass -> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO Word32) -> IO Word32)
-> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 12) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@n_values@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' flagsClass [ #nValues 'Data.GI.Base.Attributes.:=' value ]
-- @
setFlagsClassNValues :: MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassNValues :: FlagsClass -> Word32 -> m ()
setFlagsClassNValues s :: FlagsClass
s val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 12) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data FlagsClassNValuesFieldInfo
instance AttrInfo FlagsClassNValuesFieldInfo where
    type AttrBaseTypeConstraint FlagsClassNValuesFieldInfo = (~) FlagsClass
    type AttrAllowedOps FlagsClassNValuesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FlagsClassNValuesFieldInfo = (~) Word32
    type AttrTransferTypeConstraint FlagsClassNValuesFieldInfo = (~)Word32
    type AttrTransferType FlagsClassNValuesFieldInfo = Word32
    type AttrGetType FlagsClassNValuesFieldInfo = Word32
    type AttrLabel FlagsClassNValuesFieldInfo = "n_values"
    type AttrOrigin FlagsClassNValuesFieldInfo = FlagsClass
    attrGet = getFlagsClassNValues
    attrSet = setFlagsClassNValues
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

flagsClass_nValues :: AttrLabelProxy "nValues"
flagsClass_nValues = AttrLabelProxy

#endif


-- | Get the value of the “@values@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' flagsClass #values
-- @
getFlagsClassValues :: MonadIO m => FlagsClass -> m (Maybe GObject.FlagsValue.FlagsValue)
getFlagsClassValues :: FlagsClass -> m (Maybe FlagsValue)
getFlagsClassValues s :: FlagsClass
s = IO (Maybe FlagsValue) -> m (Maybe FlagsValue)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FlagsValue) -> m (Maybe FlagsValue))
-> IO (Maybe FlagsValue) -> m (Maybe FlagsValue)
forall a b. (a -> b) -> a -> b
$ FlagsClass
-> (Ptr FlagsClass -> IO (Maybe FlagsValue))
-> IO (Maybe FlagsValue)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO (Maybe FlagsValue))
 -> IO (Maybe FlagsValue))
-> (Ptr FlagsClass -> IO (Maybe FlagsValue))
-> IO (Maybe FlagsValue)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    Ptr FlagsValue
val <- Ptr (Ptr FlagsValue) -> IO (Ptr FlagsValue)
forall a. Storable a => Ptr a -> IO a
peek (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr (Ptr FlagsValue)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (Ptr GObject.FlagsValue.FlagsValue)
    Maybe FlagsValue
result <- Ptr FlagsValue
-> (Ptr FlagsValue -> IO FlagsValue) -> IO (Maybe FlagsValue)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr FlagsValue
val ((Ptr FlagsValue -> IO FlagsValue) -> IO (Maybe FlagsValue))
-> (Ptr FlagsValue -> IO FlagsValue) -> IO (Maybe FlagsValue)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr FlagsValue
val' -> do
        FlagsValue
val'' <- ((ManagedPtr FlagsValue -> FlagsValue)
-> Ptr FlagsValue -> IO FlagsValue
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr FlagsValue -> FlagsValue
GObject.FlagsValue.FlagsValue) Ptr FlagsValue
val'
        FlagsValue -> IO FlagsValue
forall (m :: * -> *) a. Monad m => a -> m a
return FlagsValue
val''
    Maybe FlagsValue -> IO (Maybe FlagsValue)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FlagsValue
result

-- | Set the value of the “@values@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' flagsClass [ #values 'Data.GI.Base.Attributes.:=' value ]
-- @
setFlagsClassValues :: MonadIO m => FlagsClass -> Ptr GObject.FlagsValue.FlagsValue -> m ()
setFlagsClassValues :: FlagsClass -> Ptr FlagsValue -> m ()
setFlagsClassValues s :: FlagsClass
s val :: Ptr FlagsValue
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    Ptr (Ptr FlagsValue) -> Ptr FlagsValue -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr (Ptr FlagsValue)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr FlagsValue
val :: Ptr GObject.FlagsValue.FlagsValue)

-- | Set the value of the “@values@” 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' #values
-- @
clearFlagsClassValues :: MonadIO m => FlagsClass -> m ()
clearFlagsClassValues :: FlagsClass -> m ()
clearFlagsClassValues s :: FlagsClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr FlagsClass
ptr -> do
    Ptr (Ptr FlagsValue) -> Ptr FlagsValue -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr (Ptr FlagsValue)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr FlagsValue
forall a. Ptr a
FP.nullPtr :: Ptr GObject.FlagsValue.FlagsValue)

#if defined(ENABLE_OVERLOADING)
data FlagsClassValuesFieldInfo
instance AttrInfo FlagsClassValuesFieldInfo where
    type AttrBaseTypeConstraint FlagsClassValuesFieldInfo = (~) FlagsClass
    type AttrAllowedOps FlagsClassValuesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FlagsClassValuesFieldInfo = (~) (Ptr GObject.FlagsValue.FlagsValue)
    type AttrTransferTypeConstraint FlagsClassValuesFieldInfo = (~)(Ptr GObject.FlagsValue.FlagsValue)
    type AttrTransferType FlagsClassValuesFieldInfo = (Ptr GObject.FlagsValue.FlagsValue)
    type AttrGetType FlagsClassValuesFieldInfo = Maybe GObject.FlagsValue.FlagsValue
    type AttrLabel FlagsClassValuesFieldInfo = "values"
    type AttrOrigin FlagsClassValuesFieldInfo = FlagsClass
    attrGet = getFlagsClassValues
    attrSet = setFlagsClassValues
    attrConstruct = undefined
    attrClear = clearFlagsClassValues
    attrTransfer _ v = do
        return v

flagsClass_values :: AttrLabelProxy "values"
flagsClass_values = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FlagsClass
type instance O.AttributeList FlagsClass = FlagsClassAttributeList
type FlagsClassAttributeList = ('[ '("gTypeClass", FlagsClassGTypeClassFieldInfo), '("mask", FlagsClassMaskFieldInfo), '("nValues", FlagsClassNValuesFieldInfo), '("values", FlagsClassValuesFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveFlagsClassMethod (t :: Symbol) (o :: *) :: * where
    ResolveFlagsClassMethod l o = O.MethodResolutionFailed l o

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

#endif