{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.LogField
(
LogField(..) ,
newZeroLogField ,
noLogField ,
#if defined(ENABLE_OVERLOADING)
ResolveLogFieldMethod ,
#endif
clearLogFieldKey ,
getLogFieldKey ,
#if defined(ENABLE_OVERLOADING)
logField_key ,
#endif
setLogFieldKey ,
getLogFieldLength ,
#if defined(ENABLE_OVERLOADING)
logField_length ,
#endif
setLogFieldLength ,
clearLogFieldValue ,
getLogFieldValue ,
#if defined(ENABLE_OVERLOADING)
logField_value ,
#endif
setLogFieldValue ,
) 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
newtype LogField = LogField (ManagedPtr LogField)
deriving (Eq)
instance WrappedPtr LogField where
wrappedPtrCalloc = callocBytes 12
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 12 >=> wrapPtr LogField)
wrappedPtrFree = Just ptr_to_g_free
newZeroLogField :: MonadIO m => m LogField
newZeroLogField = liftIO $ wrappedPtrCalloc >>= wrapPtr LogField
instance tag ~ 'AttrSet => Constructible LogField tag where
new _ attrs = do
o <- newZeroLogField
GI.Attributes.set o attrs
return o
noLogField :: Maybe LogField
noLogField = Nothing
getLogFieldKey :: MonadIO m => LogField -> m (Maybe T.Text)
getLogFieldKey s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 0) :: IO CString
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- cstringToText val'
return val''
return result
setLogFieldKey :: MonadIO m => LogField -> CString -> m ()
setLogFieldKey s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (val :: CString)
clearLogFieldKey :: MonadIO m => LogField -> m ()
clearLogFieldKey s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data LogFieldKeyFieldInfo
instance AttrInfo LogFieldKeyFieldInfo where
type AttrBaseTypeConstraint LogFieldKeyFieldInfo = (~) LogField
type AttrAllowedOps LogFieldKeyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint LogFieldKeyFieldInfo = (~) CString
type AttrTransferTypeConstraint LogFieldKeyFieldInfo = (~)CString
type AttrTransferType LogFieldKeyFieldInfo = CString
type AttrGetType LogFieldKeyFieldInfo = Maybe T.Text
type AttrLabel LogFieldKeyFieldInfo = "key"
type AttrOrigin LogFieldKeyFieldInfo = LogField
attrGet = getLogFieldKey
attrSet = setLogFieldKey
attrConstruct = undefined
attrClear = clearLogFieldKey
attrTransfer _ v = do
return v
logField_key :: AttrLabelProxy "key"
logField_key = AttrLabelProxy
#endif
getLogFieldValue :: MonadIO m => LogField -> m (Ptr ())
getLogFieldValue s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 4) :: IO (Ptr ())
return val
setLogFieldValue :: MonadIO m => LogField -> Ptr () -> m ()
setLogFieldValue s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 4) (val :: Ptr ())
clearLogFieldValue :: MonadIO m => LogField -> m ()
clearLogFieldValue s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 4) (FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data LogFieldValueFieldInfo
instance AttrInfo LogFieldValueFieldInfo where
type AttrBaseTypeConstraint LogFieldValueFieldInfo = (~) LogField
type AttrAllowedOps LogFieldValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint LogFieldValueFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint LogFieldValueFieldInfo = (~)(Ptr ())
type AttrTransferType LogFieldValueFieldInfo = (Ptr ())
type AttrGetType LogFieldValueFieldInfo = Ptr ()
type AttrLabel LogFieldValueFieldInfo = "value"
type AttrOrigin LogFieldValueFieldInfo = LogField
attrGet = getLogFieldValue
attrSet = setLogFieldValue
attrConstruct = undefined
attrClear = clearLogFieldValue
attrTransfer _ v = do
return v
logField_value :: AttrLabelProxy "value"
logField_value = AttrLabelProxy
#endif
getLogFieldLength :: MonadIO m => LogField -> m Int32
getLogFieldLength s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 8) :: IO Int32
return val
setLogFieldLength :: MonadIO m => LogField -> Int32 -> m ()
setLogFieldLength s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (val :: Int32)
#if defined(ENABLE_OVERLOADING)
data LogFieldLengthFieldInfo
instance AttrInfo LogFieldLengthFieldInfo where
type AttrBaseTypeConstraint LogFieldLengthFieldInfo = (~) LogField
type AttrAllowedOps LogFieldLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint LogFieldLengthFieldInfo = (~) Int32
type AttrTransferTypeConstraint LogFieldLengthFieldInfo = (~)Int32
type AttrTransferType LogFieldLengthFieldInfo = Int32
type AttrGetType LogFieldLengthFieldInfo = Int32
type AttrLabel LogFieldLengthFieldInfo = "length"
type AttrOrigin LogFieldLengthFieldInfo = LogField
attrGet = getLogFieldLength
attrSet = setLogFieldLength
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
logField_length :: AttrLabelProxy "length"
logField_length = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList LogField
type instance O.AttributeList LogField = LogFieldAttributeList
type LogFieldAttributeList = ('[ '("key", LogFieldKeyFieldInfo), '("value", LogFieldValueFieldInfo), '("length", LogFieldLengthFieldInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveLogFieldMethod (t :: Symbol) (o :: *) :: * where
ResolveLogFieldMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveLogFieldMethod t LogField, O.MethodInfo info LogField p) => OL.IsLabel t (LogField -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif