{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.WebKit2.Structs.FeatureList
(
FeatureList(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveFeatureListMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
FeatureListGetMethodInfo ,
#endif
featureListGet ,
#if defined(ENABLE_OVERLOADING)
FeatureListGetLengthMethodInfo ,
#endif
featureListGetLength ,
#if defined(ENABLE_OVERLOADING)
FeatureListRefMethodInfo ,
#endif
featureListRef ,
#if defined(ENABLE_OVERLOADING)
FeatureListUnrefMethodInfo ,
#endif
featureListUnref ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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 Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums
import {-# SOURCE #-} qualified GI.WebKit2.Structs.Feature as WebKit2.Feature
#else
import {-# SOURCE #-} qualified GI.WebKit2.Structs.Feature as WebKit2.Feature
#endif
newtype FeatureList = FeatureList (SP.ManagedPtr FeatureList)
deriving (FeatureList -> FeatureList -> Bool
(FeatureList -> FeatureList -> Bool)
-> (FeatureList -> FeatureList -> Bool) -> Eq FeatureList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FeatureList -> FeatureList -> Bool
== :: FeatureList -> FeatureList -> Bool
$c/= :: FeatureList -> FeatureList -> Bool
/= :: FeatureList -> FeatureList -> Bool
Eq)
instance SP.ManagedPtrNewtype FeatureList where
toManagedPtr :: FeatureList -> ManagedPtr FeatureList
toManagedPtr (FeatureList ManagedPtr FeatureList
p) = ManagedPtr FeatureList
p
foreign import ccall "webkit_feature_list_get_type" c_webkit_feature_list_get_type ::
IO GType
type instance O.ParentTypes FeatureList = '[]
instance O.HasParentTypes FeatureList
instance B.Types.TypedObject FeatureList where
glibType :: IO GType
glibType = IO GType
c_webkit_feature_list_get_type
instance B.Types.GBoxed FeatureList
instance B.GValue.IsGValue (Maybe FeatureList) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_webkit_feature_list_get_type
gvalueSet_ :: Ptr GValue -> Maybe FeatureList -> IO ()
gvalueSet_ Ptr GValue
gv Maybe FeatureList
P.Nothing = Ptr GValue -> Ptr FeatureList -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr FeatureList
forall a. Ptr a
FP.nullPtr :: FP.Ptr FeatureList)
gvalueSet_ Ptr GValue
gv (P.Just FeatureList
obj) = FeatureList -> (Ptr FeatureList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FeatureList
obj (Ptr GValue -> Ptr FeatureList -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe FeatureList)
gvalueGet_ Ptr GValue
gv = do
Ptr FeatureList
ptr <- Ptr GValue -> IO (Ptr FeatureList)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr FeatureList)
if Ptr FeatureList
ptr Ptr FeatureList -> Ptr FeatureList -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr FeatureList
forall a. Ptr a
FP.nullPtr
then FeatureList -> Maybe FeatureList
forall a. a -> Maybe a
P.Just (FeatureList -> Maybe FeatureList)
-> IO FeatureList -> IO (Maybe FeatureList)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr FeatureList -> FeatureList)
-> Ptr FeatureList -> IO FeatureList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr FeatureList -> FeatureList
FeatureList Ptr FeatureList
ptr
else Maybe FeatureList -> IO (Maybe FeatureList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FeatureList
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FeatureList
type instance O.AttributeList FeatureList = FeatureListAttributeList
type FeatureListAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "webkit_feature_list_get" webkit_feature_list_get ::
Ptr FeatureList ->
FCT.CSize ->
IO (Ptr WebKit2.Feature.Feature)
featureListGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
FeatureList
-> FCT.CSize
-> m WebKit2.Feature.Feature
featureListGet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FeatureList -> CSize -> m Feature
featureListGet FeatureList
featureList CSize
index = IO Feature -> m Feature
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Feature -> m Feature) -> IO Feature -> m Feature
forall a b. (a -> b) -> a -> b
$ do
Ptr FeatureList
featureList' <- FeatureList -> IO (Ptr FeatureList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FeatureList
featureList
Ptr Feature
result <- Ptr FeatureList -> CSize -> IO (Ptr Feature)
webkit_feature_list_get Ptr FeatureList
featureList' CSize
index
Text -> Ptr Feature -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"featureListGet" Ptr Feature
result
Feature
result' <- ((ManagedPtr Feature -> Feature) -> Ptr Feature -> IO Feature
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Feature -> Feature
WebKit2.Feature.Feature) Ptr Feature
result
FeatureList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr FeatureList
featureList
Feature -> IO Feature
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Feature
result'
#if defined(ENABLE_OVERLOADING)
data FeatureListGetMethodInfo
instance (signature ~ (FCT.CSize -> m WebKit2.Feature.Feature), MonadIO m) => O.OverloadedMethod FeatureListGetMethodInfo FeatureList signature where
overloadedMethod = featureListGet
instance O.OverloadedMethodInfo FeatureListGetMethodInfo FeatureList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.WebKit2.Structs.FeatureList.featureListGet",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.31/docs/GI-WebKit2-Structs-FeatureList.html#v:featureListGet"
})
#endif
foreign import ccall "webkit_feature_list_get_length" webkit_feature_list_get_length ::
Ptr FeatureList ->
IO FCT.CSize
featureListGetLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
FeatureList
-> m FCT.CSize
featureListGetLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FeatureList -> m CSize
featureListGetLength FeatureList
featureList = IO CSize -> m CSize
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ do
Ptr FeatureList
featureList' <- FeatureList -> IO (Ptr FeatureList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FeatureList
featureList
CSize
result <- Ptr FeatureList -> IO CSize
webkit_feature_list_get_length Ptr FeatureList
featureList'
FeatureList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr FeatureList
featureList
CSize -> IO CSize
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CSize
result
#if defined(ENABLE_OVERLOADING)
data FeatureListGetLengthMethodInfo
instance (signature ~ (m FCT.CSize), MonadIO m) => O.OverloadedMethod FeatureListGetLengthMethodInfo FeatureList signature where
overloadedMethod = featureListGetLength
instance O.OverloadedMethodInfo FeatureListGetLengthMethodInfo FeatureList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.WebKit2.Structs.FeatureList.featureListGetLength",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.31/docs/GI-WebKit2-Structs-FeatureList.html#v:featureListGetLength"
})
#endif
foreign import ccall "webkit_feature_list_ref" webkit_feature_list_ref ::
Ptr FeatureList ->
IO (Ptr FeatureList)
featureListRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
FeatureList
-> m FeatureList
featureListRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FeatureList -> m FeatureList
featureListRef FeatureList
featureList = IO FeatureList -> m FeatureList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FeatureList -> m FeatureList)
-> IO FeatureList -> m FeatureList
forall a b. (a -> b) -> a -> b
$ do
Ptr FeatureList
featureList' <- FeatureList -> IO (Ptr FeatureList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FeatureList
featureList
Ptr FeatureList
result <- Ptr FeatureList -> IO (Ptr FeatureList)
webkit_feature_list_ref Ptr FeatureList
featureList'
Text -> Ptr FeatureList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"featureListRef" Ptr FeatureList
result
FeatureList
result' <- ((ManagedPtr FeatureList -> FeatureList)
-> Ptr FeatureList -> IO FeatureList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr FeatureList -> FeatureList
FeatureList) Ptr FeatureList
result
FeatureList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr FeatureList
featureList
FeatureList -> IO FeatureList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FeatureList
result'
#if defined(ENABLE_OVERLOADING)
data FeatureListRefMethodInfo
instance (signature ~ (m FeatureList), MonadIO m) => O.OverloadedMethod FeatureListRefMethodInfo FeatureList signature where
overloadedMethod = featureListRef
instance O.OverloadedMethodInfo FeatureListRefMethodInfo FeatureList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.WebKit2.Structs.FeatureList.featureListRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.31/docs/GI-WebKit2-Structs-FeatureList.html#v:featureListRef"
})
#endif
foreign import ccall "webkit_feature_list_unref" webkit_feature_list_unref ::
Ptr FeatureList ->
IO ()
featureListUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
FeatureList
-> m ()
featureListUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FeatureList -> m ()
featureListUnref FeatureList
featureList = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr FeatureList
featureList' <- FeatureList -> IO (Ptr FeatureList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FeatureList
featureList
Ptr FeatureList -> IO ()
webkit_feature_list_unref Ptr FeatureList
featureList'
FeatureList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr FeatureList
featureList
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data FeatureListUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod FeatureListUnrefMethodInfo FeatureList signature where
overloadedMethod = featureListUnref
instance O.OverloadedMethodInfo FeatureListUnrefMethodInfo FeatureList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.WebKit2.Structs.FeatureList.featureListUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.31/docs/GI-WebKit2-Structs-FeatureList.html#v:featureListUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveFeatureListMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveFeatureListMethod "get" o = FeatureListGetMethodInfo
ResolveFeatureListMethod "ref" o = FeatureListRefMethodInfo
ResolveFeatureListMethod "unref" o = FeatureListUnrefMethodInfo
ResolveFeatureListMethod "getLength" o = FeatureListGetLengthMethodInfo
ResolveFeatureListMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveFeatureListMethod t FeatureList, O.OverloadedMethod info FeatureList p) => OL.IsLabel t (FeatureList -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveFeatureListMethod t FeatureList, O.OverloadedMethod info FeatureList p, R.HasField t FeatureList p) => R.HasField t FeatureList p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveFeatureListMethod t FeatureList, O.OverloadedMethodInfo info FeatureList) => OL.IsLabel t (O.MethodProxy info FeatureList) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif