{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

The class of a flags type holds information about its
possible values.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.GObject.Structs.FlagsClass
    ( 

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


 -- * Properties
-- ** gTypeClass #attr:gTypeClass#
{- | the parent class
-}
#if ENABLE_OVERLOADING
    flagsClass_gTypeClass                   ,
#endif
    getFlagsClassGTypeClass                 ,


-- ** mask #attr:mask#
{- | a mask covering all possible values.
-}
#if ENABLE_OVERLOADING
    flagsClass_mask                         ,
#endif
    getFlagsClassMask                       ,
    setFlagsClassMask                       ,


-- ** nValues #attr:nValues#
{- | the number of possible values.
-}
#if ENABLE_OVERLOADING
    flagsClass_nValues                      ,
#endif
    getFlagsClassNValues                    ,
    setFlagsClassNValues                    ,


-- ** values #attr:values#
{- | an array of 'GI.GObject.Structs.FlagsValue.FlagsValue' structs describing the
 individual values.
-}
    clearFlagsClassValues                   ,
#if 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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

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)
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 (FunPtr (Ptr FlagsClass -> IO ()))
wrappedPtrFree = FunPtr (Ptr FlagsClass -> IO ())
-> Maybe (FunPtr (Ptr FlagsClass -> IO ()))
forall a. a -> Maybe a
Just FunPtr (Ptr FlagsClass -> IO ())
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 ENABLE_OVERLOADING
data FlagsClassGTypeClassFieldInfo
instance AttrInfo FlagsClassGTypeClassFieldInfo where
    type AttrAllowedOps FlagsClassGTypeClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint FlagsClassGTypeClassFieldInfo = (~) (Ptr GObject.TypeClass.TypeClass)
    type AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo = (~) FlagsClass
    type AttrGetType FlagsClassGTypeClassFieldInfo = GObject.TypeClass.TypeClass
    type AttrLabel FlagsClassGTypeClassFieldInfo = "g_type_class"
    type AttrOrigin FlagsClassGTypeClassFieldInfo = FlagsClass
    attrGet _ = getFlagsClassGTypeClass
    attrSet _ = undefined
    attrConstruct = undefined
    attrClear _ = 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 ENABLE_OVERLOADING
data FlagsClassMaskFieldInfo
instance AttrInfo FlagsClassMaskFieldInfo where
    type AttrAllowedOps FlagsClassMaskFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FlagsClassMaskFieldInfo = (~) Word32
    type AttrBaseTypeConstraint FlagsClassMaskFieldInfo = (~) FlagsClass
    type AttrGetType FlagsClassMaskFieldInfo = Word32
    type AttrLabel FlagsClassMaskFieldInfo = "mask"
    type AttrOrigin FlagsClassMaskFieldInfo = FlagsClass
    attrGet _ = getFlagsClassMask
    attrSet _ = setFlagsClassMask
    attrConstruct = undefined
    attrClear _ = undefined

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 ENABLE_OVERLOADING
data FlagsClassNValuesFieldInfo
instance AttrInfo FlagsClassNValuesFieldInfo where
    type AttrAllowedOps FlagsClassNValuesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FlagsClassNValuesFieldInfo = (~) Word32
    type AttrBaseTypeConstraint FlagsClassNValuesFieldInfo = (~) FlagsClass
    type AttrGetType FlagsClassNValuesFieldInfo = Word32
    type AttrLabel FlagsClassNValuesFieldInfo = "n_values"
    type AttrOrigin FlagsClassNValuesFieldInfo = FlagsClass
    attrGet _ = getFlagsClassNValues
    attrSet _ = setFlagsClassNValues
    attrConstruct = undefined
    attrClear _ = undefined

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 ENABLE_OVERLOADING
data FlagsClassValuesFieldInfo
instance AttrInfo FlagsClassValuesFieldInfo where
    type AttrAllowedOps FlagsClassValuesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FlagsClassValuesFieldInfo = (~) (Ptr GObject.FlagsValue.FlagsValue)
    type AttrBaseTypeConstraint FlagsClassValuesFieldInfo = (~) FlagsClass
    type AttrGetType FlagsClassValuesFieldInfo = Maybe GObject.FlagsValue.FlagsValue
    type AttrLabel FlagsClassValuesFieldInfo = "values"
    type AttrOrigin FlagsClassValuesFieldInfo = FlagsClass
    attrGet _ = getFlagsClassValues
    attrSet _ = setFlagsClassValues
    attrConstruct = undefined
    attrClear _ = clearFlagsClassValues

flagsClass_values :: AttrLabelProxy "values"
flagsClass_values = AttrLabelProxy

#endif



#if 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 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) => O.IsLabelProxy t (FlagsClass -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

#endif