{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Contains a set of toggle-able web engine features.
-- 
-- The list supports passing around a set of [struct/@feature@/] objects and
-- iterating over them:
-- 
-- 
-- === /c code/
-- >g_autoptr(WebKitFeatureList) list = webkit_settings_get_experimental_features();
-- >for (gsize i = 0; i < webkit_feature_list_get_length(list): i++) {
-- >    WebKitFeature *feature = webkit_feature_list_get(list, i);
-- >    // Do something with "feature".
-- >}
-- 
-- 
-- Lists of features can be obtained with
-- @/Settings.get_experimental_features/@,
-- @/Settings.get_development_features/@, and
-- @/Settings.get_all_features/@.
-- 
-- /Since: 2.42/

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

module GI.WebKit2.Structs.FeatureList
    ( 

-- * Exported types
    FeatureList(..)                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [get]("GI.WebKit2.Structs.FeatureList#g:method:get"), [ref]("GI.WebKit2.Structs.FeatureList#g:method:ref"), [unref]("GI.WebKit2.Structs.FeatureList#g:method:unref").
-- 
-- ==== Getters
-- [getLength]("GI.WebKit2.Structs.FeatureList#g:method:getLength").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveFeatureListMethod                ,
#endif

-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    FeatureListGetMethodInfo                ,
#endif
    featureListGet                          ,


-- ** getLength #method:getLength#

#if defined(ENABLE_OVERLOADING)
    FeatureListGetLengthMethodInfo          ,
#endif
    featureListGetLength                    ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    FeatureListRefMethodInfo                ,
#endif
    featureListRef                          ,


-- ** unref #method:unref#

#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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#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

-- | Memory-managed wrapper type.
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

-- | Convert 'FeatureList' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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

-- method FeatureList::get
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "feature_list"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "FeatureList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitFeatureList"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index"
--           , argType = TBasicType TSize
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "index of the feature"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "WebKit2" , name = "Feature" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_feature_list_get" webkit_feature_list_get :: 
    Ptr FeatureList ->                      -- feature_list : TInterface (Name {namespace = "WebKit2", name = "FeatureList"})
    FCT.CSize ->                            -- index : TBasicType TSize
    IO (Ptr WebKit2.Feature.Feature)

-- | Gets a feature given its index.
-- 
-- /Since: 2.42/
featureListGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FeatureList
    -- ^ /@featureList@/: a t'GI.WebKit2.Structs.FeatureList.FeatureList'
    -> FCT.CSize
    -- ^ /@index@/: index of the feature
    -> m WebKit2.Feature.Feature
    -- ^ __Returns:__ The feature at /@index@/.
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

-- method FeatureList::get_length
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "feature_list"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "FeatureList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitFeatureList"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TSize)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_feature_list_get_length" webkit_feature_list_get_length :: 
    Ptr FeatureList ->                      -- feature_list : TInterface (Name {namespace = "WebKit2", name = "FeatureList"})
    IO FCT.CSize

-- | Gets the number of elements in the feature list.
featureListGetLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FeatureList
    -- ^ /@featureList@/: a t'GI.WebKit2.Structs.FeatureList.FeatureList'
    -> m FCT.CSize
    -- ^ __Returns:__ number of elements.
    -- 
    -- Since 2.42
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

-- method FeatureList::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "feature_list"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "FeatureList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitFeatureList"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "WebKit2" , name = "FeatureList" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_feature_list_ref" webkit_feature_list_ref :: 
    Ptr FeatureList ->                      -- feature_list : TInterface (Name {namespace = "WebKit2", name = "FeatureList"})
    IO (Ptr FeatureList)

-- | Atomically acquires a reference on the given /@featureList@/.
-- 
-- This function is MT-safe and may be called from any thread.
-- 
-- /Since: 2.42/
featureListRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FeatureList
    -- ^ /@featureList@/: a t'GI.WebKit2.Structs.FeatureList.FeatureList'
    -> m FeatureList
    -- ^ __Returns:__ The same /@featureList@/ with an additional reference.
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

-- method FeatureList::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "feature_list"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "FeatureList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitFeatureList"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_feature_list_unref" webkit_feature_list_unref :: 
    Ptr FeatureList ->                      -- feature_list : TInterface (Name {namespace = "WebKit2", name = "FeatureList"})
    IO ()

-- | Atomically releases a reference on the given /@featureList@/.
-- 
-- If the reference was the last, the resources associated to the
-- /@featureList@/ are freed. This function is MT-safe and may be called
-- from any thread.
-- 
-- /Since: 2.42/
featureListUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FeatureList
    -- ^ /@featureList@/: a t'GI.WebKit2.Structs.FeatureList.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