{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Gtk.Structs.AccelGroupEntry
    ( 

-- * Exported types
    AccelGroupEntry(..)                     ,
    newZeroAccelGroupEntry                  ,
    noAccelGroupEntry                       ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveAccelGroupEntryMethod            ,
#endif




 -- * Properties
-- ** accelPathQuark #attr:accelPathQuark#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    accelGroupEntry_accelPathQuark          ,
#endif
    getAccelGroupEntryAccelPathQuark        ,
    setAccelGroupEntryAccelPathQuark        ,


-- ** closure #attr:closure#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    accelGroupEntry_closure                 ,
#endif
    clearAccelGroupEntryClosure             ,
    getAccelGroupEntryClosure               ,
    setAccelGroupEntryClosure               ,


-- ** key #attr:key#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    accelGroupEntry_key                     ,
#endif
    getAccelGroupEntryKey                   ,




    ) 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.Gtk.Structs.AccelKey as Gtk.AccelKey

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

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

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


-- | A convenience alias for `Nothing` :: `Maybe` `AccelGroupEntry`.
noAccelGroupEntry :: Maybe AccelGroupEntry
noAccelGroupEntry :: Maybe AccelGroupEntry
noAccelGroupEntry = Maybe AccelGroupEntry
forall a. Maybe a
Nothing

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

#if defined(ENABLE_OVERLOADING)
data AccelGroupEntryKeyFieldInfo
instance AttrInfo AccelGroupEntryKeyFieldInfo where
    type AttrBaseTypeConstraint AccelGroupEntryKeyFieldInfo = (~) AccelGroupEntry
    type AttrAllowedOps AccelGroupEntryKeyFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint AccelGroupEntryKeyFieldInfo = (~) (Ptr Gtk.AccelKey.AccelKey)
    type AttrTransferTypeConstraint AccelGroupEntryKeyFieldInfo = (~)(Ptr Gtk.AccelKey.AccelKey)
    type AttrTransferType AccelGroupEntryKeyFieldInfo = (Ptr Gtk.AccelKey.AccelKey)
    type AttrGetType AccelGroupEntryKeyFieldInfo = Gtk.AccelKey.AccelKey
    type AttrLabel AccelGroupEntryKeyFieldInfo = "key"
    type AttrOrigin AccelGroupEntryKeyFieldInfo = AccelGroupEntry
    attrGet = getAccelGroupEntryKey
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

accelGroupEntry_key :: AttrLabelProxy "key"
accelGroupEntry_key = AttrLabelProxy

#endif


-- | Get the value of the “@closure@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' accelGroupEntry #closure
-- @
getAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> m (Maybe (GClosure ()))
getAccelGroupEntryClosure :: AccelGroupEntry -> m (Maybe (GClosure ()))
getAccelGroupEntryClosure s :: AccelGroupEntry
s = IO (Maybe (GClosure ())) -> m (Maybe (GClosure ()))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (GClosure ())) -> m (Maybe (GClosure ())))
-> IO (Maybe (GClosure ())) -> m (Maybe (GClosure ()))
forall a b. (a -> b) -> a -> b
$ AccelGroupEntry
-> (Ptr AccelGroupEntry -> IO (Maybe (GClosure ())))
-> IO (Maybe (GClosure ()))
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AccelGroupEntry
s ((Ptr AccelGroupEntry -> IO (Maybe (GClosure ())))
 -> IO (Maybe (GClosure ())))
-> (Ptr AccelGroupEntry -> IO (Maybe (GClosure ())))
-> IO (Maybe (GClosure ()))
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr AccelGroupEntry
ptr -> do
    Ptr (GClosure ())
val <- Ptr (Ptr (GClosure ())) -> IO (Ptr (GClosure ()))
forall a. Storable a => Ptr a -> IO a
peek (Ptr AccelGroupEntry
ptr Ptr AccelGroupEntry -> Int -> Ptr (Ptr (GClosure ()))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (Ptr (GClosure ()))
    Maybe (GClosure ())
result <- Ptr (GClosure ())
-> (Ptr (GClosure ()) -> IO (GClosure ()))
-> IO (Maybe (GClosure ()))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (GClosure ())
val ((Ptr (GClosure ()) -> IO (GClosure ()))
 -> IO (Maybe (GClosure ())))
-> (Ptr (GClosure ()) -> IO (GClosure ()))
-> IO (Maybe (GClosure ()))
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr (GClosure ())
val' -> do
        GClosure ()
val'' <- (Ptr (GClosure ()) -> IO (GClosure ())
forall a. Ptr (GClosure a) -> IO (GClosure a)
B.GClosure.newGClosureFromPtr (Ptr (GClosure ()) -> IO (GClosure ()))
-> (Ptr (GClosure ()) -> Ptr (GClosure ()))
-> Ptr (GClosure ())
-> IO (GClosure ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr (GClosure ()) -> Ptr (GClosure ())
forall a b. Ptr a -> Ptr b
FP.castPtr) Ptr (GClosure ())
val'
        GClosure () -> IO (GClosure ())
forall (m :: * -> *) a. Monad m => a -> m a
return GClosure ()
val''
    Maybe (GClosure ()) -> IO (Maybe (GClosure ()))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (GClosure ())
result

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

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

#if defined(ENABLE_OVERLOADING)
data AccelGroupEntryClosureFieldInfo
instance AttrInfo AccelGroupEntryClosureFieldInfo where
    type AttrBaseTypeConstraint AccelGroupEntryClosureFieldInfo = (~) AccelGroupEntry
    type AttrAllowedOps AccelGroupEntryClosureFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AccelGroupEntryClosureFieldInfo = (~) (Ptr (GClosure ()))
    type AttrTransferTypeConstraint AccelGroupEntryClosureFieldInfo = (~)(Ptr (GClosure ()))
    type AttrTransferType AccelGroupEntryClosureFieldInfo = (Ptr (GClosure ()))
    type AttrGetType AccelGroupEntryClosureFieldInfo = Maybe (GClosure ())
    type AttrLabel AccelGroupEntryClosureFieldInfo = "closure"
    type AttrOrigin AccelGroupEntryClosureFieldInfo = AccelGroupEntry
    attrGet = getAccelGroupEntryClosure
    attrSet = setAccelGroupEntryClosure
    attrConstruct = undefined
    attrClear = clearAccelGroupEntryClosure
    attrTransfer _ v = do
        return v

accelGroupEntry_closure :: AttrLabelProxy "closure"
accelGroupEntry_closure = AttrLabelProxy

#endif


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

-- | Set the value of the “@accel_path_quark@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' accelGroupEntry [ #accelPathQuark 'Data.GI.Base.Attributes.:=' value ]
-- @
setAccelGroupEntryAccelPathQuark :: MonadIO m => AccelGroupEntry -> Word32 -> m ()
setAccelGroupEntryAccelPathQuark :: AccelGroupEntry -> Word32 -> m ()
setAccelGroupEntryAccelPathQuark s :: AccelGroupEntry
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
$ AccelGroupEntry -> (Ptr AccelGroupEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AccelGroupEntry
s ((Ptr AccelGroupEntry -> IO ()) -> IO ())
-> (Ptr AccelGroupEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr AccelGroupEntry
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AccelGroupEntry
ptr Ptr AccelGroupEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data AccelGroupEntryAccelPathQuarkFieldInfo
instance AttrInfo AccelGroupEntryAccelPathQuarkFieldInfo where
    type AttrBaseTypeConstraint AccelGroupEntryAccelPathQuarkFieldInfo = (~) AccelGroupEntry
    type AttrAllowedOps AccelGroupEntryAccelPathQuarkFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AccelGroupEntryAccelPathQuarkFieldInfo = (~) Word32
    type AttrTransferTypeConstraint AccelGroupEntryAccelPathQuarkFieldInfo = (~)Word32
    type AttrTransferType AccelGroupEntryAccelPathQuarkFieldInfo = Word32
    type AttrGetType AccelGroupEntryAccelPathQuarkFieldInfo = Word32
    type AttrLabel AccelGroupEntryAccelPathQuarkFieldInfo = "accel_path_quark"
    type AttrOrigin AccelGroupEntryAccelPathQuarkFieldInfo = AccelGroupEntry
    attrGet = getAccelGroupEntryAccelPathQuark
    attrSet = setAccelGroupEntryAccelPathQuark
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

accelGroupEntry_accelPathQuark :: AttrLabelProxy "accelPathQuark"
accelGroupEntry_accelPathQuark = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AccelGroupEntry
type instance O.AttributeList AccelGroupEntry = AccelGroupEntryAttributeList
type AccelGroupEntryAttributeList = ('[ '("key", AccelGroupEntryKeyFieldInfo), '("closure", AccelGroupEntryClosureFieldInfo), '("accelPathQuark", AccelGroupEntryAccelPathQuarkFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif