{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A fundamental type that describes a 32-bit flag bitfield, with 32-bit
-- mask indicating which of the bits in the field are explicitly set.

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

module GI.Gst.Objects.FlagSet
    ( 

-- * Exported types
    FlagSet(..)                             ,
    IsFlagSet                               ,
    toFlagSet                               ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveFlagSetMethod                    ,
#endif

-- ** register #method:register#

    flagSetRegister                         ,




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


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

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

foreign import ccall "gst_flagset_get_type"
    c_gst_flagset_get_type :: IO B.Types.GType

instance B.Types.TypedObject FlagSet where
    glibType :: IO GType
glibType = IO GType
c_gst_flagset_get_type

-- | Type class for types which can be safely cast to `FlagSet`, for instance with `toFlagSet`.
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf FlagSet o) => IsFlagSet o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf FlagSet o) => IsFlagSet o

instance O.HasParentTypes FlagSet
type instance O.ParentTypes FlagSet = '[]

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

--- XXX Missing getter and/or setter, so no GValue instance could be generated.
#if defined(ENABLE_OVERLOADING)
type family ResolveFlagSetMethod (t :: Symbol) (o :: *) :: * where
    ResolveFlagSetMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFlagSetMethod t FlagSet, O.OverloadedMethod info FlagSet p) => OL.IsLabel t (FlagSet -> 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 ~ ResolveFlagSetMethod t FlagSet, O.OverloadedMethod info FlagSet p, R.HasField t FlagSet p) => R.HasField t FlagSet p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveFlagSetMethod t FlagSet, O.OverloadedMethodInfo info FlagSet) => OL.IsLabel t (O.MethodProxy info FlagSet) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance BoxedPtr FlagSet where
    boxedPtrCopy :: FlagSet -> IO FlagSet
boxedPtrCopy = FlagSet -> IO FlagSet
forall (m :: * -> *) a. Monad m => a -> m a
return
    boxedPtrFree :: FlagSet -> IO ()
boxedPtrFree = \FlagSet
_x -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- method FlagSet::register
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "flags_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GType of a #G_TYPE_FLAGS type."
--                 , 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_flagset_register" gst_flagset_register :: 
    CGType ->                               -- flags_type : TBasicType TGType
    IO CGType

-- | Create a new sub-class of @/GST_TYPE_FLAG_SET/@
-- which will pretty-print the human-readable flags
-- when serializing, for easier debugging.
-- 
-- /Since: 1.6/
flagSetRegister ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GType
    -- ^ /@flagsType@/: a t'GType' of a @/G_TYPE_FLAGS/@ type.
    -> m GType
flagSetRegister :: forall (m :: * -> *). (HasCallStack, MonadIO m) => GType -> m GType
flagSetRegister GType
flagsType = 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
    let flagsType' :: CGType
flagsType' = GType -> CGType
gtypeToCGType GType
flagsType
    CGType
result <- CGType -> IO CGType
gst_flagset_register CGType
flagsType'
    let result' :: GType
result' = CGType -> GType
GType CGType
result
    GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'

#if defined(ENABLE_OVERLOADING)
#endif