{- |
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 'GI.Pango.Structs.LogAttr.LogAttr' structure stores information
about the attributes of a single character.
-}

module GI.Pango.Structs.LogAttr
    ( 

-- * Exported types
    LogAttr(..)                             ,
    newZeroLogAttr                          ,
    noLogAttr                               ,


 -- * Properties
-- ** backspaceDeletesCharacter #attr:backspaceDeletesCharacter#
    getLogAttrBackspaceDeletesCharacter     ,
    logAttr_backspaceDeletesCharacter       ,
    setLogAttrBackspaceDeletesCharacter     ,


-- ** isCharBreak #attr:isCharBreak#
    getLogAttrIsCharBreak                   ,
    logAttr_isCharBreak                     ,
    setLogAttrIsCharBreak                   ,


-- ** isCursorPosition #attr:isCursorPosition#
    getLogAttrIsCursorPosition              ,
    logAttr_isCursorPosition                ,
    setLogAttrIsCursorPosition              ,


-- ** isExpandableSpace #attr:isExpandableSpace#
    getLogAttrIsExpandableSpace             ,
    logAttr_isExpandableSpace               ,
    setLogAttrIsExpandableSpace             ,


-- ** isLineBreak #attr:isLineBreak#
    getLogAttrIsLineBreak                   ,
    logAttr_isLineBreak                     ,
    setLogAttrIsLineBreak                   ,


-- ** isMandatoryBreak #attr:isMandatoryBreak#
    getLogAttrIsMandatoryBreak              ,
    logAttr_isMandatoryBreak                ,
    setLogAttrIsMandatoryBreak              ,


-- ** isSentenceBoundary #attr:isSentenceBoundary#
    getLogAttrIsSentenceBoundary            ,
    logAttr_isSentenceBoundary              ,
    setLogAttrIsSentenceBoundary            ,


-- ** isSentenceEnd #attr:isSentenceEnd#
    getLogAttrIsSentenceEnd                 ,
    logAttr_isSentenceEnd                   ,
    setLogAttrIsSentenceEnd                 ,


-- ** isSentenceStart #attr:isSentenceStart#
    getLogAttrIsSentenceStart               ,
    logAttr_isSentenceStart                 ,
    setLogAttrIsSentenceStart               ,


-- ** isWhite #attr:isWhite#
    getLogAttrIsWhite                       ,
    logAttr_isWhite                         ,
    setLogAttrIsWhite                       ,


-- ** isWordBoundary #attr:isWordBoundary#
    getLogAttrIsWordBoundary                ,
    logAttr_isWordBoundary                  ,
    setLogAttrIsWordBoundary                ,


-- ** isWordEnd #attr:isWordEnd#
    getLogAttrIsWordEnd                     ,
    logAttr_isWordEnd                       ,
    setLogAttrIsWordEnd                     ,


-- ** isWordStart #attr:isWordStart#
    getLogAttrIsWordStart                   ,
    logAttr_isWordStart                     ,
    setLogAttrIsWordStart                   ,




    ) 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.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


newtype LogAttr = LogAttr (ManagedPtr LogAttr)
instance WrappedPtr LogAttr where
    wrappedPtrCalloc = callocBytes 52
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 52 >=> wrapPtr LogAttr)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `LogAttr` struct initialized to zero.
newZeroLogAttr :: MonadIO m => m LogAttr
newZeroLogAttr = liftIO $ wrappedPtrCalloc >>= wrapPtr LogAttr

instance tag ~ 'AttrSet => Constructible LogAttr tag where
    new _ attrs = do
        o <- newZeroLogAttr
        GI.Attributes.set o attrs
        return o


noLogAttr :: Maybe LogAttr
noLogAttr = Nothing

getLogAttrIsLineBreak :: MonadIO m => LogAttr -> m Word32
getLogAttrIsLineBreak s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

setLogAttrIsLineBreak :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsLineBreak s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

data LogAttrIsLineBreakFieldInfo
instance AttrInfo LogAttrIsLineBreakFieldInfo where
    type AttrAllowedOps LogAttrIsLineBreakFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsLineBreakFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsLineBreakFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsLineBreakFieldInfo = Word32
    type AttrLabel LogAttrIsLineBreakFieldInfo = "is_line_break"
    type AttrOrigin LogAttrIsLineBreakFieldInfo = LogAttr
    attrGet _ = getLogAttrIsLineBreak
    attrSet _ = setLogAttrIsLineBreak
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isLineBreak :: AttrLabelProxy "isLineBreak"
logAttr_isLineBreak = AttrLabelProxy


getLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> m Word32
getLogAttrIsMandatoryBreak s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 4) :: IO Word32
    return val

setLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsMandatoryBreak s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 4) (val :: Word32)

data LogAttrIsMandatoryBreakFieldInfo
instance AttrInfo LogAttrIsMandatoryBreakFieldInfo where
    type AttrAllowedOps LogAttrIsMandatoryBreakFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsMandatoryBreakFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsMandatoryBreakFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsMandatoryBreakFieldInfo = Word32
    type AttrLabel LogAttrIsMandatoryBreakFieldInfo = "is_mandatory_break"
    type AttrOrigin LogAttrIsMandatoryBreakFieldInfo = LogAttr
    attrGet _ = getLogAttrIsMandatoryBreak
    attrSet _ = setLogAttrIsMandatoryBreak
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isMandatoryBreak :: AttrLabelProxy "isMandatoryBreak"
logAttr_isMandatoryBreak = AttrLabelProxy


getLogAttrIsCharBreak :: MonadIO m => LogAttr -> m Word32
getLogAttrIsCharBreak s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word32
    return val

setLogAttrIsCharBreak :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsCharBreak s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Word32)

data LogAttrIsCharBreakFieldInfo
instance AttrInfo LogAttrIsCharBreakFieldInfo where
    type AttrAllowedOps LogAttrIsCharBreakFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsCharBreakFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsCharBreakFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsCharBreakFieldInfo = Word32
    type AttrLabel LogAttrIsCharBreakFieldInfo = "is_char_break"
    type AttrOrigin LogAttrIsCharBreakFieldInfo = LogAttr
    attrGet _ = getLogAttrIsCharBreak
    attrSet _ = setLogAttrIsCharBreak
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isCharBreak :: AttrLabelProxy "isCharBreak"
logAttr_isCharBreak = AttrLabelProxy


getLogAttrIsWhite :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWhite s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Word32
    return val

setLogAttrIsWhite :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWhite s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 12) (val :: Word32)

data LogAttrIsWhiteFieldInfo
instance AttrInfo LogAttrIsWhiteFieldInfo where
    type AttrAllowedOps LogAttrIsWhiteFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWhiteFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWhiteFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWhiteFieldInfo = Word32
    type AttrLabel LogAttrIsWhiteFieldInfo = "is_white"
    type AttrOrigin LogAttrIsWhiteFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWhite
    attrSet _ = setLogAttrIsWhite
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWhite :: AttrLabelProxy "isWhite"
logAttr_isWhite = AttrLabelProxy


getLogAttrIsCursorPosition :: MonadIO m => LogAttr -> m Word32
getLogAttrIsCursorPosition s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word32
    return val

setLogAttrIsCursorPosition :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsCursorPosition s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word32)

data LogAttrIsCursorPositionFieldInfo
instance AttrInfo LogAttrIsCursorPositionFieldInfo where
    type AttrAllowedOps LogAttrIsCursorPositionFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsCursorPositionFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsCursorPositionFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsCursorPositionFieldInfo = Word32
    type AttrLabel LogAttrIsCursorPositionFieldInfo = "is_cursor_position"
    type AttrOrigin LogAttrIsCursorPositionFieldInfo = LogAttr
    attrGet _ = getLogAttrIsCursorPosition
    attrSet _ = setLogAttrIsCursorPosition
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isCursorPosition :: AttrLabelProxy "isCursorPosition"
logAttr_isCursorPosition = AttrLabelProxy


getLogAttrIsWordStart :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWordStart s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 20) :: IO Word32
    return val

setLogAttrIsWordStart :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWordStart s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 20) (val :: Word32)

data LogAttrIsWordStartFieldInfo
instance AttrInfo LogAttrIsWordStartFieldInfo where
    type AttrAllowedOps LogAttrIsWordStartFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWordStartFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWordStartFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWordStartFieldInfo = Word32
    type AttrLabel LogAttrIsWordStartFieldInfo = "is_word_start"
    type AttrOrigin LogAttrIsWordStartFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWordStart
    attrSet _ = setLogAttrIsWordStart
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWordStart :: AttrLabelProxy "isWordStart"
logAttr_isWordStart = AttrLabelProxy


getLogAttrIsWordEnd :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWordEnd s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

setLogAttrIsWordEnd :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWordEnd s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

data LogAttrIsWordEndFieldInfo
instance AttrInfo LogAttrIsWordEndFieldInfo where
    type AttrAllowedOps LogAttrIsWordEndFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWordEndFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWordEndFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWordEndFieldInfo = Word32
    type AttrLabel LogAttrIsWordEndFieldInfo = "is_word_end"
    type AttrOrigin LogAttrIsWordEndFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWordEnd
    attrSet _ = setLogAttrIsWordEnd
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWordEnd :: AttrLabelProxy "isWordEnd"
logAttr_isWordEnd = AttrLabelProxy


getLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> m Word32
getLogAttrIsSentenceBoundary s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 28) :: IO Word32
    return val

setLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsSentenceBoundary s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 28) (val :: Word32)

data LogAttrIsSentenceBoundaryFieldInfo
instance AttrInfo LogAttrIsSentenceBoundaryFieldInfo where
    type AttrAllowedOps LogAttrIsSentenceBoundaryFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsSentenceBoundaryFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsSentenceBoundaryFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsSentenceBoundaryFieldInfo = Word32
    type AttrLabel LogAttrIsSentenceBoundaryFieldInfo = "is_sentence_boundary"
    type AttrOrigin LogAttrIsSentenceBoundaryFieldInfo = LogAttr
    attrGet _ = getLogAttrIsSentenceBoundary
    attrSet _ = setLogAttrIsSentenceBoundary
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isSentenceBoundary :: AttrLabelProxy "isSentenceBoundary"
logAttr_isSentenceBoundary = AttrLabelProxy


getLogAttrIsSentenceStart :: MonadIO m => LogAttr -> m Word32
getLogAttrIsSentenceStart s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word32
    return val

setLogAttrIsSentenceStart :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsSentenceStart s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Word32)

data LogAttrIsSentenceStartFieldInfo
instance AttrInfo LogAttrIsSentenceStartFieldInfo where
    type AttrAllowedOps LogAttrIsSentenceStartFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsSentenceStartFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsSentenceStartFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsSentenceStartFieldInfo = Word32
    type AttrLabel LogAttrIsSentenceStartFieldInfo = "is_sentence_start"
    type AttrOrigin LogAttrIsSentenceStartFieldInfo = LogAttr
    attrGet _ = getLogAttrIsSentenceStart
    attrSet _ = setLogAttrIsSentenceStart
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isSentenceStart :: AttrLabelProxy "isSentenceStart"
logAttr_isSentenceStart = AttrLabelProxy


getLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> m Word32
getLogAttrIsSentenceEnd s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 36) :: IO Word32
    return val

setLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsSentenceEnd s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 36) (val :: Word32)

data LogAttrIsSentenceEndFieldInfo
instance AttrInfo LogAttrIsSentenceEndFieldInfo where
    type AttrAllowedOps LogAttrIsSentenceEndFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsSentenceEndFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsSentenceEndFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsSentenceEndFieldInfo = Word32
    type AttrLabel LogAttrIsSentenceEndFieldInfo = "is_sentence_end"
    type AttrOrigin LogAttrIsSentenceEndFieldInfo = LogAttr
    attrGet _ = getLogAttrIsSentenceEnd
    attrSet _ = setLogAttrIsSentenceEnd
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isSentenceEnd :: AttrLabelProxy "isSentenceEnd"
logAttr_isSentenceEnd = AttrLabelProxy


getLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> m Word32
getLogAttrBackspaceDeletesCharacter s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO Word32
    return val

setLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrBackspaceDeletesCharacter s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: Word32)

data LogAttrBackspaceDeletesCharacterFieldInfo
instance AttrInfo LogAttrBackspaceDeletesCharacterFieldInfo where
    type AttrAllowedOps LogAttrBackspaceDeletesCharacterFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrBackspaceDeletesCharacterFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrBackspaceDeletesCharacterFieldInfo = (~) LogAttr
    type AttrGetType LogAttrBackspaceDeletesCharacterFieldInfo = Word32
    type AttrLabel LogAttrBackspaceDeletesCharacterFieldInfo = "backspace_deletes_character"
    type AttrOrigin LogAttrBackspaceDeletesCharacterFieldInfo = LogAttr
    attrGet _ = getLogAttrBackspaceDeletesCharacter
    attrSet _ = setLogAttrBackspaceDeletesCharacter
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_backspaceDeletesCharacter :: AttrLabelProxy "backspaceDeletesCharacter"
logAttr_backspaceDeletesCharacter = AttrLabelProxy


getLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> m Word32
getLogAttrIsExpandableSpace s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 44) :: IO Word32
    return val

setLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsExpandableSpace s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 44) (val :: Word32)

data LogAttrIsExpandableSpaceFieldInfo
instance AttrInfo LogAttrIsExpandableSpaceFieldInfo where
    type AttrAllowedOps LogAttrIsExpandableSpaceFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsExpandableSpaceFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsExpandableSpaceFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsExpandableSpaceFieldInfo = Word32
    type AttrLabel LogAttrIsExpandableSpaceFieldInfo = "is_expandable_space"
    type AttrOrigin LogAttrIsExpandableSpaceFieldInfo = LogAttr
    attrGet _ = getLogAttrIsExpandableSpace
    attrSet _ = setLogAttrIsExpandableSpace
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isExpandableSpace :: AttrLabelProxy "isExpandableSpace"
logAttr_isExpandableSpace = AttrLabelProxy


getLogAttrIsWordBoundary :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWordBoundary s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO Word32
    return val

setLogAttrIsWordBoundary :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWordBoundary s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: Word32)

data LogAttrIsWordBoundaryFieldInfo
instance AttrInfo LogAttrIsWordBoundaryFieldInfo where
    type AttrAllowedOps LogAttrIsWordBoundaryFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWordBoundaryFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWordBoundaryFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWordBoundaryFieldInfo = Word32
    type AttrLabel LogAttrIsWordBoundaryFieldInfo = "is_word_boundary"
    type AttrOrigin LogAttrIsWordBoundaryFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWordBoundary
    attrSet _ = setLogAttrIsWordBoundary
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWordBoundary :: AttrLabelProxy "isWordBoundary"
logAttr_isWordBoundary = AttrLabelProxy



instance O.HasAttributeList LogAttr
type instance O.AttributeList LogAttr = LogAttrAttributeList
type LogAttrAttributeList = ('[ '("isLineBreak", LogAttrIsLineBreakFieldInfo), '("isMandatoryBreak", LogAttrIsMandatoryBreakFieldInfo), '("isCharBreak", LogAttrIsCharBreakFieldInfo), '("isWhite", LogAttrIsWhiteFieldInfo), '("isCursorPosition", LogAttrIsCursorPositionFieldInfo), '("isWordStart", LogAttrIsWordStartFieldInfo), '("isWordEnd", LogAttrIsWordEndFieldInfo), '("isSentenceBoundary", LogAttrIsSentenceBoundaryFieldInfo), '("isSentenceStart", LogAttrIsSentenceStartFieldInfo), '("isSentenceEnd", LogAttrIsSentenceEndFieldInfo), '("backspaceDeletesCharacter", LogAttrBackspaceDeletesCharacterFieldInfo), '("isExpandableSpace", LogAttrIsExpandableSpaceFieldInfo), '("isWordBoundary", LogAttrIsWordBoundaryFieldInfo)] :: [(Symbol, *)])

type family ResolveLogAttrMethod (t :: Symbol) (o :: *) :: * where
    ResolveLogAttrMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveLogAttrMethod t LogAttr, O.MethodInfo info LogAttr p) => O.IsLabelProxy t (LogAttr -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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