{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Use 'GI.Gst.Objects.TracerFactory.tracerFactoryGetList' to get a list of tracer factories known to
-- GStreamer.
-- 
-- /Since: 1.8/

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

module GI.Gst.Objects.TracerFactory
    ( 

-- * Exported types
    TracerFactory(..)                       ,
    IsTracerFactory                         ,
    toTracerFactory                         ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveTracerFactoryMethod              ,
#endif


-- ** getList #method:getList#

    tracerFactoryGetList                    ,


-- ** getTracerType #method:getTracerType#

#if defined(ENABLE_OVERLOADING)
    TracerFactoryGetTracerTypeMethodInfo    ,
#endif
    tracerFactoryGetTracerType              ,




    ) 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.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 Control.Monad.IO.Class as MIO
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 qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.PluginFeature as Gst.PluginFeature

-- | Memory-managed wrapper type.
newtype TracerFactory = TracerFactory (SP.ManagedPtr TracerFactory)
    deriving (TracerFactory -> TracerFactory -> Bool
(TracerFactory -> TracerFactory -> Bool)
-> (TracerFactory -> TracerFactory -> Bool) -> Eq TracerFactory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TracerFactory -> TracerFactory -> Bool
$c/= :: TracerFactory -> TracerFactory -> Bool
== :: TracerFactory -> TracerFactory -> Bool
$c== :: TracerFactory -> TracerFactory -> Bool
Eq)

instance SP.ManagedPtrNewtype TracerFactory where
    toManagedPtr :: TracerFactory -> ManagedPtr TracerFactory
toManagedPtr (TracerFactory ManagedPtr TracerFactory
p) = ManagedPtr TracerFactory
p

foreign import ccall "gst_tracer_factory_get_type"
    c_gst_tracer_factory_get_type :: IO B.Types.GType

instance B.Types.TypedObject TracerFactory where
    glibType :: IO GType
glibType = IO GType
c_gst_tracer_factory_get_type

instance B.Types.GObject TracerFactory

-- | Convert 'TracerFactory' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue TracerFactory where
    toGValue :: TracerFactory -> IO GValue
toGValue TracerFactory
o = do
        GType
gtype <- IO GType
c_gst_tracer_factory_get_type
        TracerFactory -> (Ptr TracerFactory -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TracerFactory
o (GType
-> (GValue -> Ptr TracerFactory -> IO ())
-> Ptr TracerFactory
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TracerFactory -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO TracerFactory
fromGValue GValue
gv = do
        Ptr TracerFactory
ptr <- GValue -> IO (Ptr TracerFactory)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr TracerFactory)
        (ManagedPtr TracerFactory -> TracerFactory)
-> Ptr TracerFactory -> IO TracerFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TracerFactory -> TracerFactory
TracerFactory Ptr TracerFactory
ptr
        
    

-- | Type class for types which can be safely cast to `TracerFactory`, for instance with `toTracerFactory`.
class (SP.GObject o, O.IsDescendantOf TracerFactory o) => IsTracerFactory o
instance (SP.GObject o, O.IsDescendantOf TracerFactory o) => IsTracerFactory o

instance O.HasParentTypes TracerFactory
type instance O.ParentTypes TracerFactory = '[Gst.PluginFeature.PluginFeature, Gst.Object.Object, GObject.Object.Object]

-- | Cast to `TracerFactory`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTracerFactory :: (MonadIO m, IsTracerFactory o) => o -> m TracerFactory
toTracerFactory :: o -> m TracerFactory
toTracerFactory = IO TracerFactory -> m TracerFactory
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TracerFactory -> m TracerFactory)
-> (o -> IO TracerFactory) -> o -> m TracerFactory
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TracerFactory -> TracerFactory)
-> o -> IO TracerFactory
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr TracerFactory -> TracerFactory
TracerFactory

#if defined(ENABLE_OVERLOADING)
type family ResolveTracerFactoryMethod (t :: Symbol) (o :: *) :: * where
    ResolveTracerFactoryMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveTracerFactoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTracerFactoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTracerFactoryMethod "checkVersion" o = Gst.PluginFeature.PluginFeatureCheckVersionMethodInfo
    ResolveTracerFactoryMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveTracerFactoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTracerFactoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTracerFactoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTracerFactoryMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveTracerFactoryMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveTracerFactoryMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveTracerFactoryMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveTracerFactoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTracerFactoryMethod "load" o = Gst.PluginFeature.PluginFeatureLoadMethodInfo
    ResolveTracerFactoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTracerFactoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTracerFactoryMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveTracerFactoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTracerFactoryMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveTracerFactoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTracerFactoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTracerFactoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTracerFactoryMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveTracerFactoryMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveTracerFactoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTracerFactoryMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveTracerFactoryMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveTracerFactoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTracerFactoryMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveTracerFactoryMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveTracerFactoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTracerFactoryMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveTracerFactoryMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveTracerFactoryMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveTracerFactoryMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveTracerFactoryMethod "getPlugin" o = Gst.PluginFeature.PluginFeatureGetPluginMethodInfo
    ResolveTracerFactoryMethod "getPluginName" o = Gst.PluginFeature.PluginFeatureGetPluginNameMethodInfo
    ResolveTracerFactoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTracerFactoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTracerFactoryMethod "getRank" o = Gst.PluginFeature.PluginFeatureGetRankMethodInfo
    ResolveTracerFactoryMethod "getTracerType" o = TracerFactoryGetTracerTypeMethodInfo
    ResolveTracerFactoryMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveTracerFactoryMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveTracerFactoryMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveTracerFactoryMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveTracerFactoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTracerFactoryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTracerFactoryMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveTracerFactoryMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveTracerFactoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTracerFactoryMethod "setRank" o = Gst.PluginFeature.PluginFeatureSetRankMethodInfo
    ResolveTracerFactoryMethod l o = O.MethodResolutionFailed l o

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

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TracerFactory
type instance O.AttributeList TracerFactory = TracerFactoryAttributeList
type TracerFactoryAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TracerFactory = TracerFactorySignalList
type TracerFactorySignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method TracerFactory::get_tracer_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "factory"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "TracerFactory" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "factory to get managed #GType from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "gst_tracer_factory_get_tracer_type" gst_tracer_factory_get_tracer_type :: 
    Ptr TracerFactory ->                    -- factory : TInterface (Name {namespace = "Gst", name = "TracerFactory"})
    IO CGType

-- | Get the t'GType' for elements managed by this factory. The type can
-- only be retrieved if the element factory is loaded, which can be
-- assured with 'GI.Gst.Objects.PluginFeature.pluginFeatureLoad'.
tracerFactoryGetTracerType ::
    (B.CallStack.HasCallStack, MonadIO m, IsTracerFactory a) =>
    a
    -- ^ /@factory@/: factory to get managed t'GType' from
    -> m GType
    -- ^ __Returns:__ the t'GType' for tracers managed by this factory or 0 if
    -- the factory is not loaded.
tracerFactoryGetTracerType :: a -> m GType
tracerFactoryGetTracerType a
factory = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
    Ptr TracerFactory
factory' <- a -> IO (Ptr TracerFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
    CGType
result <- Ptr TracerFactory -> IO CGType
gst_tracer_factory_get_tracer_type Ptr TracerFactory
factory'
    let result' :: GType
result' = CGType -> GType
GType CGType
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
factory
    GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'

#if defined(ENABLE_OVERLOADING)
data TracerFactoryGetTracerTypeMethodInfo
instance (signature ~ (m GType), MonadIO m, IsTracerFactory a) => O.MethodInfo TracerFactoryGetTracerTypeMethodInfo a signature where
    overloadedMethod = tracerFactoryGetTracerType

#endif

-- method TracerFactory::get_list
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "Gst" , name = "TracerFactory" }))
-- throws : False
-- Skip return : False

foreign import ccall "gst_tracer_factory_get_list" gst_tracer_factory_get_list :: 
    IO (Ptr (GList (Ptr TracerFactory)))

-- | Gets the list of all registered tracer factories. You must free the
-- list using 'GI.Gst.Objects.PluginFeature.pluginFeatureListFree'.
-- 
-- The returned factories are sorted by factory name.
-- 
-- Free-function: gst_plugin_feature_list_free
-- 
-- /Since: 1.8/
tracerFactoryGetList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m [TracerFactory]
    -- ^ __Returns:__ the list of all
    --     registered t'GI.Gst.Objects.TracerFactory.TracerFactory'.
tracerFactoryGetList :: m [TracerFactory]
tracerFactoryGetList  = IO [TracerFactory] -> m [TracerFactory]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TracerFactory] -> m [TracerFactory])
-> IO [TracerFactory] -> m [TracerFactory]
forall a b. (a -> b) -> a -> b
$ do
    Ptr (GList (Ptr TracerFactory))
result <- IO (Ptr (GList (Ptr TracerFactory)))
gst_tracer_factory_get_list
    [Ptr TracerFactory]
result' <- Ptr (GList (Ptr TracerFactory)) -> IO [Ptr TracerFactory]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr TracerFactory))
result
    [TracerFactory]
result'' <- (Ptr TracerFactory -> IO TracerFactory)
-> [Ptr TracerFactory] -> IO [TracerFactory]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr TracerFactory -> TracerFactory)
-> Ptr TracerFactory -> IO TracerFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TracerFactory -> TracerFactory
TracerFactory) [Ptr TracerFactory]
result'
    Ptr (GList (Ptr TracerFactory)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr TracerFactory))
result
    [TracerFactory] -> IO [TracerFactory]
forall (m :: * -> *) a. Monad m => a -> m a
return [TracerFactory]
result''

#if defined(ENABLE_OVERLOADING)
#endif